Changeset 933ed8 in git

Timestamp:

Apr 18, 2020, 12:13:54 PM (4 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

4922ad56a6e60def4b4595cad0a4d77f563bfe73

Parents:

161411bdc5cc30f7965d2c36a5250edcb33d293ee645dbb37f4b69d6e6c541745eaba9b6e9450b23

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2020-04-18 12:13:54+02:00

git-committer:

GitHub <noreply@github.com>2020-04-18 12:13:54+02:00

Message:

Merge pull request #988 from levandov/spielwiese

letterplace big doc update

Files:

• Singular/LIB/dmodapp.lib (modified) (4 diffs)
• Singular/LIB/freegb.lib (modified) (13 diffs)
• doc/NEWS-letterplace.texi (added)
• doc/letterplace.doc (modified) (previous)
• doc/plulibs.doc (modified) (previous)
• doc/plural.doc (modified) (previous)

Singular/LIB/dmodapp.lib

@@ -140 +140 @@
   - changed charVariety: no homogenization is needed
   - changed inForm: code is much simpler using jet
+  
+  06.04.20 by VL:
+  - engine updated with 2 more modular choices
 
 */
@@ -153 +156 @@
 LIB "qhmoduli.lib"; // for Max
 LIB "sing.lib";     // for slocus
+LIB "ncModslimgb.lib"; // for modular noncomm GB
 
 
@@ -263 +267 @@
 
 proc engine(def I, int i)
+"USAGE:  engine(I,i);  I ideal/module/matrix, i an int
+RETURN:  the same type as I
+PURPOSE: compute the Groebner basis of I with the algorithm, chosen via i
+NOTE:    By default and if i=0, slimgb is used; 
+if i=1, std does the job;
+if i=2, modular slimgb is run without final exactness check;
+if i=3, modular slimgb is run with final exactness check.
+EXAMPLE: example engine; shows examples
+"
+{
+  /* std - slimgb mix */
+  def J;
+  //  ideal J;
+  if ((i<=0) || (i>=4))
+  {
+      i = 0;
+      J = slimgb(I);
+  }
+  if (i==1)
+  {
+    // without options -> strange! (ringlist?)
+    intvec v = option(get);
+    option(redSB);
+    option(redTail);
+    J = std(I);
+    option(set, v);
+  }
+  if (i==2)
+  {
+      // modular slimgb without final exactness check
+      J = ncmodslimgb(I,0);
+  }
+  if (i==3)
+  {
+      // modular slimgb with final exactness check
+      J = ncmodslimgb(I,1);
+  }  
+  return(J);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r = 0,(x,y),Dp;
+  ideal I  = y*(x3-y2),x*(x3-y2);
+  engine(I,0); // uses slimgb
+  engine(I,1); // uses std
+  engine(I,2); // uses modular slimgb without exactness check
+  engine(I,3); // uses modular slimgb with exactness check
+}
+
+/* 
+proc engine(def I, int i)
 "USAGE:  engine(I,i);  I  ideal/module/matrix, i an int
 RETURN:  the same type as I
@@ -295 +351 @@
   engine(I,0); // uses slimgb
   engine(I,1); // uses std
-}
+} 
+*/
 
 proc poly2list (poly f)

Singular/LIB/freegb.lib

@@ -457 +457 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
-  def R = freeAlgebra(r, 4); // R with letterplace structure
-  setring R;
+  ring R = freeAlgebra(r, 4);
   poly a = x*y; poly b = y;
   lieBracket(a,b);
@@ -490 +489 @@
  "EXAMPLE:"; echo = 2;
  ring r = (0,a,b,g),(x,y),Dp;
- def R = freeAlgebra(r, 4); // constructs a Letterplace ring
- setring R; // downup algebra A
+ ring R = freeAlgebra(r, 4); // downup algebra A
  ideal J = x*x*y-a*x*y*x - b*y*x*x - g*x,
  x*y*y-a*y*x*y - b*y*y*x - g*y;
@@ -981 +979 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y,z),dp;
-  def R = freeAlgebra(r, 7);
+  ring R = freeAlgebra(r, 7);
   lpVarBlockSize(R);
 }
@@ -1003 +1001 @@
   ring r = 0,(x,y,z),dp;
   isFreeAlgebra(r);
-  def R = freeAlgebra(r, 7);
+  ring R = freeAlgebra(r, 7);
   isFreeAlgebra(R);
 }
@@ -1020 +1018 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y,z),dp;
-  def R = freeAlgebra(r, 7, 10);
-  lpNcgenCount(R); // should be 10
+  ring R = freeAlgebra(r, 7, 3);
+  lpNcgenCount(R); // should be 3
 }
 
@@ -2850 +2848 @@
   "EXAMPLE:"; echo = 2;
 ring r = 0,(x,y,z),dp;
-int d =5; // degree
-def R = freeAlgebra(r, d);
-setring R;
+int d = 5; // degree
+ring R = freeAlgebra(r, d);
 ideal I = y*x*y - z*y*z, x*y*x - z*x*y, z*x*z - y*z*x, x*x*x + y*y*y + z*z*z + x*y*z;
 ideal J = letplaceGBasis(I); // compute a Letterplace Groebner basis
@@ -2868 +2865 @@
 RETURN: list L
 NOTE: - L[1] is NF(p,I)
-      - L[2] is the list of expressions [i,l_(ij),r_(ij)] with \sum_(i,j) l_(ij) g_i r_(ij) = p - NF(p,I)
+      - L[2] is the list of expressions [i,l_(ij),r_(ij)] with \sum_(i,j) l_(ij) g_i r_(ij) = p - NF(p,I) 
       - procedure lpGBPres2Poly, applied to L, reconstructs p
 EXAMPLE: example lpDivision; shows examples
@@ -2940 +2937 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
-  def R = freeAlgebra(r, 4); setring R;
+  ring R = freeAlgebra(r, 4); 
   ideal I = x*x + y*y - 1; // 2D sphere
-  ideal J = letplaceGBasis(I); // compute a Letterplace Groebner basis
+  ideal J = twostd(I); // compute a two-sided Groebner basis
   J; // it is finite and nice
   poly h = x*x*y-y*x*x+x*y;
-  lpDivision(h,J); // what means that the NF of h wrt J is x*y
+  list L = lpDivision(h,J); L; // what means that the NF of h wrt J is x*y
   h - lpNF(h,J); // and this poly has the folowing two-sided Groebner presentation:
   -y*J[1] + J[1]*y;
+  lpGBPres2Poly(L,J); // reconstructs the above automatically
 }
 
@@ -2969 +2967 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,y),dp;
-  def R = freeAlgebra(r, 4); setring R;
+  ring R = freeAlgebra(r, 4); 
   ideal I = x*x + y*y - 1; // 2D sphere
-  ideal J = letplaceGBasis(I); // compute a Letterplace Groebner basis
+  ideal J = twostd(I); // compute a two-sided Groebner basis
   J; // it is finite and nice
   poly h = x*x*y-y*x*x+x*y;
-  list L = lpDivision(h,J); // what means that the NF of h wrt J is x*y
+  list L = lpDivision(h,J); 
+  L[1]; // what means that the normal form (or the remainder) of h wrt J is x*y
   lpGBPres2Poly(L,J); // we see, that it is equal to h from above
 }
-
-
 
 
@@ -3782 +3779 @@
   poly q = y*y*x*x;
   poly w = z*y*x*z;
-  // p,q,w are some polynomials we want to transform into their
+  // p, q, w are some polynomials we want to transform into their
   // intvec representation
   ideal G = p,q,w;
@@ -3788 +3785 @@
 }
 
-proc testLift(ideal M, matrix T) {
+proc testLift(ideal M, matrix T) 
+"USAGE: testLift(M,T); module M, matrix T
+RETURN: module
+PURPOSE: assembles the result of the lift procedure
+ASSUME: T is the lift matrix of a submodule of M
+NOTE: the inverse of the lift procedure
+EXAMPLE: example testLift; shows examples
+"
+{
   ideal R;
   if (ncols(M) != nrows(T)) { ERROR("cols(M) != rows(T)") }
@@ -3799 +3804 @@
   return(R);
 }
-
-proc testSyz(ideal M, module S) {
+example
+{
+  "EXAMPLE:"; echo = 2;
+  LIB "freegb.lib";
+  ring r = 0,(x,y),(c,Dp);
+  ring R = freeAlgebra(r, 7, 2);
+  ideal I = std(x*y*x + 1);
+  print(matrix(I)); // finite two-sided Groebner basis
+  ideal SI = x*I[1]*y + y*x*I[2], I[1]*y*x + I[2]*y;
+  matrix T = lift(I, SI); // T is the lifting matrix of SI wrt I
+  print(T); //
+  print(matrix(SI)); // the original generators of SI as a matrix
+  print(matrix(testLift(I,T))); // and the result of testLift
+}
+
+proc testSyz(ideal M, module S)
+"USAGE: testSyz(M,S); module M, S
+RETURN: module
+PURPOSE: tests the result of the syz procedure
+ASSUME: S is the syzygy bimodule of M
+EXAMPLE: example testSyz; shows examples
+"
+{
   ideal R;
   if (ncols(M) != nrows(S)) { ERROR("cols(M) != rows(T)") }
@@ -3811 +3837 @@
   return(R);
 }
+example
+{
+  "EXAMPLE:"; echo = 2;
+  LIB "freegb.lib";
+  ring r = 0,(x,y),(c,Dp);
+  ring R = freeAlgebra(r, 7, 2);
+  ideal I = twostd(x*y*x + 1);
+  print(matrix(I));
+  module S = syz(I);
+  print(S);
+  testSyz(I,S); // returns zero
+}
 
 static proc mod_init()