OpenXM/src/k097/lib/minimal/minimal.k - diff

Return to minimal.k CVS log

Up to [local] / OpenXM / src / k097 / lib / minimal

Diff for /OpenXM/src/k097/lib/minimal/minimal.k between version 1.9 and 1.13

-version 1.9, 2000/05/06 13:41:12
+version 1.13, 2000/06/08 08:37:53
 Line 1
 Line 1
 Line 1
- /* $OpenXM: OpenXM/src/k097/lib/minimal/minimal.k,v 1.8 2000/05/06 10:45:43 takayama Exp $ */
+ /* $OpenXM: OpenXM/src/k097/lib/minimal/minimal.k,v 1.12 2000/05/24 15:24:54 takayama Exp $ */
  #define DEBUG 1
  /* #define ORDINARY 1 */
  /* If you run this program on openxm version 1.1.2 (FreeBSD),
 Line 6
 Line 6
 Line 6
     ln -s /usr/bin/cpp /lib/cpp
  */
  #define OFFSET 0
- #define TOTAL_STRATEGY
+ /* #define TOTAL_STRATEGY */
  /* #define OFFSET 20*/
  /* Test sequences.
     Use load["minimal.k"];;
 Line 1044  def Sannfs2(f) {
 Line 1044  def Sannfs2(f) {
 Line 1044  def Sannfs2(f) {
    Sweyl("x,y",[["x",1,"y",1,"Dx",1,"Dy",1,"h",1],
                 ["x",-1,"y",-1,"Dx",1,"Dy",1]]); */
    /* Sweyl("x,y",[["x",1,"y",1,"Dx",1,"Dy",1,"h",1]]); */
    Sweyl("x,y",[["x",-1,"y",-1,"Dx",1,"Dy",1]]);
    pp = Map(p,"Spoly");
    return(Sminimal_v(pp));
    /* return(Sminimal(pp)); */
  }
+ HelpAdd(["Sannfs2",
+ ["Sannfs2(f) constructs the V-minimal free resolution for the weight (-1,1)",
+  "of the Laplace transform of the annihilating ideal of the polynomial f in x,y.",
+  "See also Sminimal_v, Sannfs3.",
+  "Example: a=Sannfs2(\"x^3-y^2\");",
+  "         b=a[0]; sm1_pmat(b);",
+  "         b[1]*b[0]:",
+  "Example: a=Sannfs2(\"x*y*(x-y)*(x+y)\");",
+  "         b=a[0]; sm1_pmat(b);",
+  "         b[1]*b[0]:"
+ ]]);
  /* Do not forget to turn on TOTAL_STRATEGY */
  def Sannfs2_laScala(f) {
    local p,pp;
-Line 1063  def Sannfs2_laScala(f) {
+Line 1076  def Sannfs2_laScala(f) {
 Line 1063  def Sannfs2_laScala(f) {
 Line 1076  def Sannfs2_laScala(f) {
    return(Sminimal(pp));
  }
+ def Sannfs2_laScala2(f) {
+   local p,pp;
+   p = Sannfs(f,"x,y");
+   sm1(" p 0 get { [(x) (y) (Dx) (Dy)] laplace0 } map /p set ");
+   p = [p];
+   Sweyl("x,y",[["x",1,"y",1,"Dx",1,"Dy",1,"h",1],
+                ["x",-1,"y",-1,"Dx",1,"Dy",1]]);
+   pp = Map(p[0],"Spoly");
+   return(Sminimal(pp));
+ }
  def Sannfs3(f) {
    local p,pp;
    p = Sannfs(f,"x,y,z");
-Line 1072  def Sannfs3(f) {
+Line 1096  def Sannfs3(f) {
 Line 1072  def Sannfs3(f) {
 Line 1096  def Sannfs3(f) {
    return(Sminimal_v(pp));
  }
+ HelpAdd(["Sannfs3",
+ ["Sannfs3(f) constructs the V-minimal free resolution for the weight (-1,1)",
+  "of the Laplace transform of the annihilating ideal of the polynomial f in x,y,z.",
+  "See also Sminimal_v, Sannfs2.",
+  "Example: a=Sannfs3(\"x^3-y^2*z^2\");",
+  "         b=a[0]; sm1_pmat(b);",
+  "         b[1]*b[0]: b[2]*b[1]:"]]);
  /*
    The betti numbers of most examples are 2,1. (0-th and 1-th).
    a=Sannfs2("x*y*(x+y-1)"); ==> The betti numbers are 3, 2.
-Line 1080  def Sannfs3(f) {
+Line 1112  def Sannfs3(f) {
 Line 1080  def Sannfs3(f) {
 Line 1112  def Sannfs3(f) {
  */
+ def Sannfs3_laScala2(f) {
+   local p,pp;
+   p = Sannfs(f,"x,y,z");
+   sm1(" p 0 get { [(x) (y) (z) (Dx) (Dy) (Dz)] laplace0 } map /p set ");
+   Sweyl("x,y,z",[["x",1,"y",1,"z",1,"Dx",1,"Dy",1,"Dz",1,"h",1],
+                  ["x",-1,"y",-1,"z",-1,"Dx",1,"Dy",1,"Dz",1]]);
+   pp = Map(p,"Spoly");
+   return(Sminimal(pp));
+ }
  /*  The below does not use LaScala-Stillman's algorithm. */
-Line 1331  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
+Line 1372  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
 Line 1331  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
 Line 1372  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
    Print("vdegree of the original = "); Println(vdeg);
    Print("vdegree of the remainder = "); Println(vdeg_reduced);
+   if (!IsNull(vdeg_reduced)) {
+     if (vdeg_reduced < vdeg) {
+       Println("--- Special in V-minimal!");
+       Println(tmp[0]);
+       Println("syzygy="); sm1_pmat(t_syz);
+       Print("[vdeg, vdeg_reduced] = "); Println([vdeg,vdeg_reduced]);
+     }
+   }
    pos = SwhereInTower(syzHead,tower[level]);
    pos2 = SwhereInTower(tmp[0],tower[level-1]);
    ans = [tmp[0],t_syz,pos,pos2,vdeg,vdeg_reduced,c2];
-Line 1341  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
+Line 1392  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
 Line 1341  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
 Line 1392  def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,
    return(ans);
  }
+ HelpAdd(["Sminimal_v",
+ ["It constructs the V-minimal free resolution from the Schreyer resolution",
+  "step by step.",
+  "Example:   Sweyl(\"x,y\",[[\"x\",-1,\"y\",-1,\"Dx\",1,\"Dy\",1]]);",
+  "          v=[[2*x*Dx + 3*y*Dy+6, 0],",
+  "             [3*x^2*Dy + 2*y*Dx, 0],",
+  "             [0,  x^2+y^2],",
+  "             [0,  x*y]];",
+  "         a=Sminimal_v(v);",
+  "         sm1_pmat(a[0]); b=a[0]; b[1]*b[0]:",
+  "Note:  a[0] is the V-minimal resolution. a[3] is the Schreyer resolution."]]);
  def Sminimal_v(g) {
    local r, freeRes, redundantTable, reducer, maxLevel,
          minRes, seq, maxSeq, level, betti, q, bases, dr,
-         betti_levelplus, newbases, i, j,qq;
+         betti_levelplus, newbases, i, j,qq,tminRes;
    r = Sschreyer(g);
    sm1_pmat(r);
    Debug_Sminimal_v = r;
-Line 1399  def Sminimal_v(g) {
+Line 1463  def Sminimal_v(g) {
 Line 1399  def Sminimal_v(g) {
 Line 1463  def Sminimal_v(g) {
          }
        }
     }
-    return([Stetris(minRes,redundantTable),
+    tminRes = Stetris(minRes,redundantTable);
+    return([SpruneZeroRow(tminRes), tminRes,
            [ minRes, redundantTable, reducer,r[3],r[4]],r[0]]);
    /* r[4] is the redundantTable_ordinary */
    /* r[0] is the freeResolution */
  }
  /* Sannfs2("x*y*(x-y)*(x+y)"); is a test problem */
+ /* x y (x+y-1)(x-2),  x^3-y^2, x^3 - y^2 z^2,
+    x y z (x+y+z-1) seems to be interesting, because the first syzygy
+   contains 1.
+ */
+ def CopyArray(m) {
+   local ans,i,n;
+   if (IsArray(m)) {
+      n = Length(m);
+      ans = NewArray(n);
+      for (i=0; i<n; i++) {
+        ans[i] = CopyArray(m[i]);
+      }
+      return(ans);
+   }else{
+      return(m);
+   }
+ }
+ HelpAdd(["CopyArray",
+ ["It duplicates the argument array recursively.",
+  "Example: m=[1,[2,3]];",
+  "         a=CopyArray(m); a[1] = \"Hello\";",
+  "         Println(m); Println(a);"]]);
+ def IsZeroVector(m) {
+   local n,i;
+   n = Length(m);
+   for (i=0; i<n; i++) {
+     if (!IsZero(m[i])) {
+       return(false);
+     }
+   }
+   return(true);
+ }
+ def SpruneZeroRow(res) {
+   local minRes, n,i,j,m, base,base2,newbase,newbase2, newMinRes;
+   minRes = CopyArray(res);
+   n = Length(minRes);
+   for (i=0; i<n; i++) {
+     base = minRes[i];
+     m = Length(base);
+     if (i != n-1) {
+       base2 = minRes[i+1];
+       base2 = Transpose(base2);
+     }
+     newbase = [ ];
+     newbase2 = [ ];
+     for (j=0; j<m; j++) {
+       if (!IsZeroVector(base[j])) {
+         newbase = Append(newbase,base[j]);
+         if (i != n-1) {
+           newbase2 = Append(newbase2,base2[j]);
+         }
+       }
+     }
+     minRes[i] = newbase;
+     if (i != n-1) {
+       if (newbase2 == [ ]) {
+         minRes[i+1] = [ ];
+       }else{
+         minRes[i+1] = Transpose(newbase2);
+       }
+     }
+   }
+   newMinRes = [ ];
+   n = Length(minRes);
+   i = 0;
+   while (i < n ) {
+     base = minRes[i];
+     if (base == [ ]) {
+       i = n; /* break; */
+     }else{
+       newMinRes = Append(newMinRes,base);
+     }
+     i++;
+   }
+   return(newMinRes);
+ }
+ def testAnnfs2(f) {
+   local a,i,n;
+   a = Sannfs2(f);
+   b=a[0];
+   n = Length(b);
+   Println("------ V-minimal free resolution -----");
+   sm1_pmat(b);
+   Println("----- Is it complex?  ---------------");
+   for (i=0; i<n-1; i++) {
+     Println(b[i+1]*b[i]);
+   }
+   return(a);
+ }
+ def testAnnfs3(f) {
+   local a,i,n;
+   a = Sannfs3(f);
+   b=a[0];
+   n = Length(b);
+   Println("------ V-minimal free resolution -----");
+   sm1_pmat(b);
+   Println("----- Is it complex?  ---------------");
+   for (i=0; i<n-1; i++) {
+     Println(b[i+1]*b[i]);
+   }
+   return(a);
+ }
+ def ToString_array(p) {
+   local ans;
+   if (IsArray(p)) {
+     ans = Map(p,"ToString_array");
+   }else{
+     ans = ToString(p);
+   }
+   return(ans);
+ }
+ /* sm1_res_div([[x],[y]],[[x^2],[x*y],[y^2]],[x,y]): */
+ def sm1_res_div(I,J,V) {
+   I = ToString_array(I);
+   J = ToString_array(J);
+   V = ToString_array(V);
+   sm1(" [[ I J]  V ] res*div /FunctionValue set ");
+ }
+ /* It has not yet been working */
+ def sm1_res_kernel_image(m,n,v) {
+   m = ToString_array(m);
+   n = ToString_array(n);
+   v = ToString_array(v);
+   sm1(" [m n v] res-kernel-image /FunctionValue set ");
+ }
+ def Skernel(m,v) {
+   m = ToString_array(m);
+   v = ToString_array(v);
+   sm1(" [ m v ] syz /FunctionValue set ");
+ }
+ def test3() {
+   local a1,a2,b1,b2;
+   a1 = Sannfs3("x^3-y^2*z^2");
+   a1 = a1[0];
+   a2 = Sannfs3_laScala2("x^3-y^2*z^2");
+   a2 = a2[0];
+   b1 = a1[1];
+   b2 = a2[1];
+   sm1_pmat(b2);
+   Println("  OVER ");
+   sm1_pmat(b1);
+   return([sm1_res_div(b2,b1,["x","y","z"]),b2,b1,a2,a1]);
+ }
+ def test4() {
+   local a,b;
+   a = Sannfs3_laScala2("x^3-y^2*z^2");
+   b = a[0];
+   sm1_pmat( sm1_res_kernel_image(b[0],b[1],[x,y,z]));
+   sm1_pmat( sm1_res_kernel_image(b[1],b[2],[x,y,z]));
+   return(a);
+ }
+ def sm1_gb(f,v) {
+   f =ToString_array(f);
+   v = ToString_array(v);
+   sm1(" [f v] gb /FunctionValue set ");
+ }
+ def SisExact_h(c,v) {
+   local a;
+   v = ToString_array(v);
+   a = [c,v];
+   sm1(a," isExact /FunctionValue set ");
+ }
+ def SisComplex(a) {
+   local n,i,j,k,b,p,q;
+   n = Length(a);
+   for (i=0; i<n-1; i++) {
+     if (Length(a[i+1]) != 0) {
+       b = a[i+1]*a[i];
+       p = Length(b); q = Length(b[0]);
+       for (j=0; j<p; j++) {
+         for (k=0; k<q; k++) {
+           if (!IsZero(b[j,k])) {
+              Print("Is is not complex at ");
+              Println([i,j,k]);
+              return(false);
+           }
+         }
+       }
+     }
+   }
+   return(true);
+ }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>