Changeset 166ebd2 in git

Timestamp:

Mar 29, 2011, 5:59:25 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

a796fbdaa0242a20ef39e60d40c2d02dba2c9eb4

Parents:

e7c67af3ca54121581499413ed55f282b49e8ac6

Message:

ADD: some more examples and descriptions: 'createQuotientGroup','createTorsionFreeGroup', 'isGroup', 'getGradedGenerator','createGradedRingHomomorphism' etc.
FIX: evalHilbertSeries -> static (too experimentall)

From: Oleksandr Motsak <motsak@mathematik.uni-kl.de>

git-svn-id: file:///usr/local/Singular/svn/trunk@14084 2c84dea3-7e68-4137-9b89-c4e89433aadc

File:

• Singular/LIB/multigrading.lib (modified) (24 diffs)

Singular/LIB/multigrading.lib

@@ -37 +37 @@
 printGroup(G);             print a group
 
-areIsomorphicGroups(G,H);     test wheter G an H are isomorphic groups (TODO Tuebingen)
+areIsomorphicGroups(G,H);     test wheter G an H are isomorphic groups
 isGroup(G);                   test whether G is a valid group
 isGroupHomomorphism(L1,L2,A); test wheter A defines a group homomrphism from L1 to L2
@@ -92 +92 @@
 
 hilbertSeries(M);         compute the multigraded Hilbert Series of M
-evalHilbertSeries(h,v);   evaluate hilberts series h by substituting v[i] for t_(i)
 
 lll(A);                   applies LLL(.) of lll.lib which only works for lists on a matrix A
@@ -101 +100 @@
 ";
 
+/// evalHilbertSeries(h,v);   evaluate hilberts series h by substituting v[i] for t_(i) (too experimentall)
+
 // finestMDeg(def r)
 // newMap(map F, intmat Q, list #)
 
 LIB "standard.lib"; // for groebner
-LIB "lll.lib"; // for lll_matrix
+// LIB "lll.lib"; // for lll_matrix // no need now, right?
 LIB "matrix.lib"; // for multiDegTor
 
@@ -159 +160 @@
   "EXAMPLE:"; echo=2;
 
-  // TODO!
-
+  ring r = 0, (x, y, z), dp;
+  intmat S1[3][3] =
+                   1, 0, 0,
+                   0, 1, 0,
+                   0, 0, 1;
+  intmat L1[3][1] =
+                   0,
+                   0,
+                   0;
+
+  def G1 = createGroup(S1, L1); // (S1 + L1)/L1
+  printGroup(G1);
+
+  setBaseMultigrading(S1, L1); // to change...
+
+  ring R = 0, (a, b, c), dp;
+  intmat S2[2][3] =
+                   1, 0,
+                   0, 1;
+  intmat L2[2][1] =
+                   0,
+                   2;
+
+  def G2 = createGroup(S2, L2);
+  printGroup(G2);
+
+  setBaseMultigrading(S2, L2); // to change...
+
+
+  map F = r, a, b, c;
+  intmat A[nrows(L2)][nrows(L1)] =
+                                  1, 0, 0,
+                                  3, 2, -6;
+
+  // graded ring homomorphism is given by (compatible):
+  print(F);
+  print(A);
+
+  isGradedRingHomomorphism(r, ideal(F), A);
+  def h = createGradedRingHomomorphism(r, ideal(F), A);
+
+  print(h);
 }
 
@@ -255 +296 @@
 
 proc createQuotientGroup(intmat L)
-"
-L - relations
-TODO: bad name
+"USAGE: createGroup(L); L is an integer matrix
+PURPOSE: create the group of the form (I+L)/L,
+where I is the square identity matrix of size nrows(L) x nrows(L)
+NOTE: L specifies relations between free generators of Z^nrows(L)
+RETURN: group
+EXAMPLE: example createQuotientGroup; shows an example
 "
 {
@@ -265 +309 @@
   return (createGroup(S,L));
 }
+example
+{
+  "EXAMPLE:"; echo=2;
+
+  intmat I[3][3] =
+                  1, 0, 0,
+                  0, 1, 0,
+                  0, 0, 1;
+
+  intmat L[3][2] =
+                  1, 1,
+                  1, 3,
+                  1, 5;
+
+
+  // The group Z^3 / L can be constructed as follows:
+
+  // shortcut:
+  def G = createQuotientGroup(L);
+  printGroup(G);
+
+  // the general way:
+  def GG = createGroup(I, L); // (I+L)/L
+  printGroup(GG);
+}
 
 proc createTorsionFreeGroup(intmat S)
-"
-S - generators
-TODO: bad name
+"USAGE: createTorsionFreeGroup(S); S is an integer matrix
+PURPOSE: create the free subgroup generated by S within the
+free Abelian group of rank nrows(S)
+RETURN: group
+EXAMPLE: example createTorsionFreeGroup; shows an example
 "
 {
@@ -275 +346 @@
   intmat L[r][1] = 0;
   return (createGroup(S,L));
+}
+example
+{
+  "EXAMPLE:"; echo=2;
+
+  // ----------- extreme case ------------ //
+  intmat S[1][3] =
+                  1,  -1, 10;
+
+  // Torsion:
+  intmat L[1][1] =
+                  0;
+
+
+  // The free subgroup generated by elements of S within Z^1
+  // can be constructed as follows:
+
+  // shortcut:
+  def G = createTorsionFreeGroup(S);
+  printGroup(G);
+
+  // the general way:
+  def GG = createGroup(S, L); // (S+L)/L
+  printGroup(GG);
 }
 
@@ -409 +504 @@
   "EXAMPLE:"; echo=2;
 
+  intmat S[3][3] =
+                  1, 0, 0,
+                  0, 1, 0,
+                  0, 0, 1;
+
+  intmat L[3][2] =
+                  1, 1,
+                  1, 3,
+                  1, 5;
+
+  def G = createGroup(S, L); // (S+L)/L
+  printGroup(G);
+
 }
 
 /******************************************************/
-proc areIsomorphicGroups(def G, def H)
+static proc areIsomorphicGroups(def G, def H)
 "USAGE: areIsomorphicGroups(G, H); G and H are groups
 PURPOSE: ?
@@ -426 +534 @@
   "EXAMPLE:"; echo=2;
 
-}
-
-
+  // TODO!
+
+}
+
+/******************************************************/
 proc isGroup(def G)
-"test whether G is a valid group"
+"USAGE: isGroup(G); G a list
+PURPOSE: checks whether G is a valid group
+NOTE: G should be created by createGroup
+(or createQuotientGroup, createTorsionFreeGroup)
+RETURN: int, 1 if G is a valid group and 0 otherwise
+EXAMPLE: example isGroup; shows an example
+"
 {
   string isGroup = "isGroup";
@@ -452 +568 @@
 
   return(1);
+}
+example
+{
+  "EXAMPLE:"; echo=2;
+
+  intmat S[3][3] =
+                  1, 0, 0,
+                  0, 1, 0,
+                  0, 0, 1;
+
+  intmat L[3][2] =
+                  1, 1,
+                  1, 3,
+                  1, 5;
+
+  def G = createGroup(S, L); // (S+L)/L
+
+  isGroup(G);
+  
+  printGroup(G);
+
 }
 
@@ -944 +1081 @@
 
 proc getGradedGenerator(def m, int i)
-"
-returns m[i], but with grading
+"USAGE: getGradedGenerator(M, i), 'M' module/ideal, 'i' int
+RETURN: returns the i-th generator of M, endowed with the module grading from M
+EXAMPLE: example getGradedGenerator; shows an example
 "
 {
@@ -962 +1100 @@
   ERROR("m is expected to be an ideal or a module");
 }
-
+example
+{
+  "EXAMPLE:"; echo=2;
+
+  ring r = 0,(x,y,z,w),dp;
+  intmat MM[2][4]=
+                  1,1,1,1,
+                  0,1,3,4;
+  setBaseMultigrading(MM);
+  
+  module M = ideal(  xw-yz, x2z-y3, xz2-y2w, yw2-z3);
+
+
+  intmat v[2][nrows(M)]=
+                        1,
+                        0;
+
+  M = setModuleGrading(M, v);
+
+  isHomogeneous(M);
+  "Multidegrees: "; print(multiDeg(M));
+
+  // Let's compute syzygies!
+  def S = multiDegSyzygy(M); S;
+  "Module Units Multigrading: "; print( getModuleGrading(S) );
+  "Multidegrees: "; print(multiDeg(S));
+
+  isHomogeneous(S);
+
+  // same as S[1] together with the induced module weighting
+  def v = getGradedGenerator(S, 1);
+  print(v);
+  print(setModuleGrading(v));
+  
+  isHomogeneous(v);
+
+  isHomogeneous(S[1]);
+}
 
 /******************************************************/
@@ -1472 +1647 @@
   }
 }
-
-example
-{
-
-"EXAMPLE:";
-
-ring R = 0,x,dp;
-intmat m[5][5]=13,25,37,83,294,12,-33,9,0,64,77,12,34,6,1,43,2,88,91,100,-46,32,37,42,15;
-lll(m);
-list l=intvec(13,25,37, 83, 294),intvec(12, -33, 9,0,64), intvec (77,12,34,6,1), intvec (43,2,88,91,100), intvec (-46,32,37,42,15);
-lll(l);
+example
+{
+  "EXAMPLE:"; echo=2;
+
+  ring R = 0,x,dp;
+  intmat m[5][5] =
+                  13,25,37,83,294,
+                  12,-33,9,0,64,
+                  77,12,34,6,1,
+                  43,2,88,91,100,
+                  -46,32,37,42,15;
+  lll(m);
+  
+  list l =
+      intvec(13,25,37, 83, 294),
+      intvec(12, -33, 9,0,64),
+      intvec (77,12,34,6,1),
+      intvec (43,2,88,91,100),
+      intvec (-46,32,37,42,15);
+  lll(l);
 }
 
 
 proc smithNormalForm(intmat A, list #)
-"
-This method returns 3 Matrices P, D and Q such that D = P*A*Q.
-WARNING: This might not be what you expect.
+"USAGE: smithNormalForm(A[,opt]); intmat A
+PURPOSE: Computes the Smith Normal Form of A
+RETURN: if no optional argument is given: intmat, the Smith Normal Form of A,
+otherwise: a list of 3 integer matrices P, D Q, such that D == P*A*Q.
+EXAMPLE: example smithNormalForm; shows an example
 "
 {
@@ -1556 +1742 @@
 example
 {
-"EXAMPLE: "; echo=2;
-
-intmat A[5][7] =
-1,0,1,0,-2,9,-71,
-0,-24,248,-32,-96,448,-3496,
-0,4,-42,4,-8,30,-260,
-0,0,0,18,-90,408,-3168,
-0,0,0,-32,224,-1008,7872;
-
-list l = smithNormalForm(A, 5);
-
-l;
-l[1]*A*l[3];
-det(l[1]);
-det(l[3]);
+  "EXAMPLE:"; echo=2;
+
+
+  intmat A[5][7] =
+                  1,0,1,0,-2,9,-71,
+                  0,-24,248,-32,-96,448,-3496,
+                  0,4,-42,4,-8,30,-260,
+                  0,0,0,18,-90,408,-3168,
+                  0,0,0,-32,224,-1008,7872;
+
+  print( smithNormalForm(A) );
+
+  list l = smithNormalForm(A, 5);
+
+  l;
+
+  l[1]*A*l[3];
+
+  det(l[1]);
+  det(l[3]);
 }
 
@@ -1688 +1879 @@
 
 proc areZeroElements(intmat m, list #)
-"same as isZeroElement but for an integer matrix considered as a collection of columns"
+"USAGE: areZeroElements(D, [T]); intmat D, group T
+PURPOSE: For a integer matrix D, considered column-wise as a set of
+   integer vecors representing the multidegree of some polynomial
+   or vector this method checks whether all these multidegrees
+   are contained in the grading group
+   group (either set globally or given as an optional argument),
+i.e. if they all are zero in the multigrading.
+EXAMPLE: example areZeroElements; shows an example
+"
 {
   int r = nrows(m);
@@ -1705 +1904 @@
   return(1);
 }
-
+example
+{
+  "EXAMPLE:"; echo=2;
+
+  ring r = 0,(x,y,z),dp;
+
+  intmat S[2][3]=
+    1,0,1,
+    0,1,1;
+
+  intmat L[2][1]=
+    2,
+    2;
+
+  setBaseMultigrading(S,L);
+
+  poly a = 1;
+  poly b = xyz;
+
+  ideal I = a, b;
+  print(multiDeg(I));
+  
+  intmat m[5][2]=multiDeg(a),multiDeg(b); m=transpose(m);
+
+  print(multiDeg(a));
+  print(multiDeg(b));
+
+  print(m);
+ 
+  areZeroElements(m);
+
+  intmat LL[2][1]=
+     1,
+    -1;
+
+  areZeroElements(m,LL);
+}
+
+
+/******************************************************/
+proc isZeroElement(intvec mdeg, list #)
+"USAGE: isZeroElement(d, [T]); intvec d, group T
+PURPOSE: For a integer vector 'd' representing the multidegree of some polynomial
+or vector this method computes if the multidegree is contained in the grading group
+group (either set globally or given as an optional argument), i.e. if it is zero in the multigrading.
+EXAMPLE: example isZeroElement; shows an example
+"
+{
+  int i = 1;
+  if( size(#) >= i )
+  {
+    def a = #[1];
+    if( typeof(a) == "intmat" )
+    {
+      intmat H = hermiteNormalForm(a);
+      i++;
+    }
+    if( typeof(a) == "list" )
+    {
+      list L = a;
+      intmat H = attrib(L, "hermite"); // todo
+      i++;
+    }
+    kill a;
+  }
+  
+  if( i == 1 )
+  {
+    intmat H = getLattice("hermite");
+  }
+
+  int x, k, row;
+
+  int r = nrows(H);
+  int c = ncols(H);
+
+  int rr = nrows(mdeg);
+  row = 1;
+  intvec v;
+  for(i=1; (i<=r)&&(row<=r)&&(i<=c); i++)
+  {
+    while((H[row,i]==0)&&(row<=r))
+    {
+      row++;
+      if(row == (r+1)){
+        break;
+      }
+    }
+    if(row<=r){
+      if(H[row,i]!=0)
+      {
+        v = H[1..r,i];
+        mdeg = mdeg-(mdeg[row]-mdeg[row]%v[row])/v[row]*v;
+      }
+    }
+  }
+  return( mdeg == 0 );
+
+}
 example
 {
@@ -1732 +2029 @@
   poly f = z2;
 
- intmat m[5][2]=multiDeg(a)-multiDeg(b),multiDeg(b)-multiDeg(c),multiDeg(c)-multiDeg(d),multiDeg(d)-multiDeg(e),multiDeg(e)-multiDeg(f);
- m=transpose(m);
- areZeroElements(m);
- areZeroElements(m,tt);
-}
-
-
-/******************************************************/
-proc isZeroElement(intvec mdeg, list #)
-"USAGE: isZeroElement(d, [T]); intvec d, group T
-PURPOSE: For a integer vector mdeg representing the multidegree of some polynomial
-or vector this method computes if the multidegree is contained in the grading group
-group (either set globally or given as an optional argument), i.e. if it is zero in the multigrading.
-EXAMPLE: example isZeroElement; shows an example
-"
-{
-  int i = 1;
-  if( size(#) >= i )
-  {
-    def a = #[1];
-    if( typeof(a) == "intmat" )
-    {
-      intmat H = hermiteNormalForm(a);
-      i++;
-    }
-    if( typeof(a) == "list" )
-    {
-      list L = a;
-      intmat H = attrib(L, "hermite"); // todo
-      i++;
-    }
-    kill a;
-  }
-  
-  if( i == 1 )
-  {
-    intmat H = getLattice("hermite");
-  }
-
-  int x, k, row;
-
-  int r = nrows(H);
-  int c = ncols(H);
-
-  int rr = nrows(mdeg);
-  row = 1;
-  intvec v;
-  for(i=1; (i<=r)&&(row<=r)&&(i<=c); i++)
-  {
-    while((H[row,i]==0)&&(row<=r))
-    {
-      row++;
-      if(row == (r+1)){
-        break;
-      }
-    }
-    if(row<=r){
-      if(H[row,i]!=0)
-      {
-        v = H[1..r,i];
-        mdeg = mdeg-(mdeg[row]-mdeg[row]%v[row])/v[row]*v;
-      }
-    }
-  }
-  return( mdeg == 0 );
-
-}
-example
-{
- "EXAMPLE:"; echo=2;
-
-  ring r = 0,(x,y,z),dp;
-
-  intmat g[2][3]=
-    1,0,1,
-    0,1,1;
-  intmat t[2][1]=
-    -2,
-    1;
-
-  intmat tt[2][1]=
-    1,
-    -1;
-
-  setBaseMultigrading(g,t);
-
-  poly a = x10yz;
-  poly b = x8y2z;
-  poly c = x4z2;
-  poly d = y5;
-  poly e = x2y2;
-  poly f = z2;
-
   intvec v1 = multiDeg(a) - multiDeg(b);
   v1;
@@ -1910 +2114 @@
 
 proc gradiator(def h)
-PURPOSE: coarsens the grading of the basering until the polynom or ideal h becomes homogeneous.
-
+"PURPOSE: coarsens the grading of the basering until the polynom or ideal h becomes homogeneous."
 {
   if(typeof(h)=="poly"){
@@ -1942 +2145 @@
 example
 {
-"EXAMPLE:"; echo=2;
+  "EXAMPLE:"; echo=2;
+
 ring r = 0,(x,y,z),dp;
 intmat g[2][3] = 1,0,1,0,1,1;
@@ -3067 +3271 @@
 /******************************************************/
 proc multiDegBasis(intvec d)
-"
-USAGE: multidegree d
+"USAGE: multidegree d
 ASSUME: current ring is multigraded, monomial ordering is global
 PURPOSE: compute all monomials of multidegree d
@@ -3284 +3487 @@
 {
   "EXAMPLE:"; echo=2;
-
 
   ring r = 0,(x,y,z,w),dp;
@@ -3977 +4179 @@
 }
 
-proc evalHilbertSeries(def h, intvec v)
-"
-evaluate hilbert series h by substibuting v[i] for t_(i) (1/v[i] for s_(i))
-return: int (h(v))
+static proc evalHilbertSeries(def h, intvec v)
+"
+   TODO
+   evaluate hilbert series h by substibuting v[i] for t_(i) (1/v[i] for s_(i))
+  return: int (h(v))
 "
 {
@@ -4304 +4507 @@
 /******************************************************/
 proc intRank(intmat A)
-"
-USAGE: intRank(A); intmat A
+"USAGE: intRank(A); intmat A
 PURPOSE: compute the rank of the integral matrix A
 by computing a hermite normalform.
@@ -4553 +4755 @@
 
 proc kernelLattice(def P)
-"
-USAGE: kernelLattice(P); intmat P
+"USAGE: kernelLattice(P); intmat P
 PURPOSE: compute a integral basis for the kernel of the
 homomorphism of lattices defined by the intmat P.