[BACK]Return to minimal.k CVS log [TXT][DIR] Up to [local] / OpenXM / src / k097 / lib / minimal

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

version 1.9, 2000/05/06 13:41:12 version 1.18, 2000/07/30 02:26:25
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.17 2000/07/26 12:56:36 takayama Exp $ */
 #define DEBUG 1  #define DEBUG 1
 /* #define ORDINARY 1 */  /* #define ORDINARY 1 */
 /* If you run this program on openxm version 1.1.2 (FreeBSD),  /* If you run this program on openxm version 1.1.2 (FreeBSD),
Line 6 
Line 6 
    ln -s /usr/bin/cpp /lib/cpp     ln -s /usr/bin/cpp /lib/cpp
 */  */
 #define OFFSET 0  #define OFFSET 0
 #define TOTAL_STRATEGY  
 /* #define OFFSET 20*/  /* #define OFFSET 20*/
 /* Test sequences.  /* Test sequences.
    Use load["minimal.k"];;     Use load["minimal.k"];;
Line 132  sm1(" [(AvoidTheSameRing)] pushEnv 
Line 131  sm1(" [(AvoidTheSameRing)] pushEnv 
       [ [(AvoidTheSameRing) 0] system_variable        [ [(AvoidTheSameRing) 0] system_variable
         [(gbListTower) tower (list) dc] system_variable          [(gbListTower) tower (list) dc] system_variable
       ] pop popEnv ");        ] pop popEnv ");
         /* sm1("(hoge) message show_ring "); */
 }  }
   
 def SresolutionFrameWithTower(g,opt) {  def SresolutionFrameWithTower(g,opt) {
   local gbTower, ans, ff, count, startingGB, opts, skelton,withSkel, autof,    local gbTower, ans, ff, count, startingGB, opts, skelton,withSkel, autof,
         gbasis;          gbasis, nohomog;
     nohomog = false;
     count = -1;
   if (Length(Arglist) >= 2) {    if (Length(Arglist) >= 2) {
     if (IsInteger(opt)) count = opt;      if (IsInteger(opt)) {
         count = opt;
       }else if (IsString(opt)) {
         if (opt == "homogenized") {
            nohomog = true;
         }else{
            Println("Warning: unknown option");
            Println(opt);
         }
       }
   }else{    }else{
     count = -1;      count = -1;
   }    }
Line 152  def SresolutionFrameWithTower(g,opt) {
Line 163  def SresolutionFrameWithTower(g,opt) {
   */    */
   
   sm1(" (mmLarger) (matrix) switch_function ");    sm1(" (mmLarger) (matrix) switch_function ");
   g = Map(g,"Shomogenize");    if (! nohomog) {
       Println("Automatic homogenization.");
       g = Map(g,"Shomogenize");
     }else{
       Println("No automatic homogenization.");
     }
   if (SonAutoReduce) {    if (SonAutoReduce) {
     sm1("[ (AutoReduce) ] system_variable /autof set ");      sm1("[ (AutoReduce) ] system_variable /autof set ");
     sm1("[ (AutoReduce) 1 ] system_variable ");      sm1("[ (AutoReduce) 1 ] system_variable ");
Line 192  def SresolutionFrameWithTower(g,opt) {
Line 208  def SresolutionFrameWithTower(g,opt) {
 }  }
 HelpAdd(["SresolutionFrameWithTower",  HelpAdd(["SresolutionFrameWithTower",
 ["It returs [resolution of the initial, gbTower, skelton, gbasis]",  ["It returs [resolution of the initial, gbTower, skelton, gbasis]",
    "option: \"homogenized\" (no automatic homogenization) ",
  "Example: Sweyl(\"x,y\");",   "Example: Sweyl(\"x,y\");",
  "         a=SresolutionFrameWithTower([x^3,x*y,y^3-1]);"]]);   "         a=SresolutionFrameWithTower([x^3,x*y,y^3-1]);"]]);
   
 def SresolutionFrame(f,opt) {  def SresolutionFrame(f,opt) {
   local ans;    local ans;
   ans = SresolutionFrameWithTower(f);    ans = SresolutionFrameWithTower(f,opt);
   return(ans[0]);    return(ans[0]);
 }  }
 /* ---------------------------- */  /* ---------------------------- */
Line 291  def Sres0FrameWithSkelton(g) {
Line 308  def Sres0FrameWithSkelton(g) {
   
   
 def StotalDegree(f) {  def StotalDegree(f) {
   sm1(" [(grade) f] gbext (universalNumber) dc /FunctionValue set ");    local d0;
     sm1(" [(grade) f] gbext (universalNumber) dc /d0 set ");
     /* Print("degree of "); Print(f); Print(" is "); Println(d0); */
     return(d0);
 }  }
   
 /* Sord_w(x^2*Dx*Dy,[x,-1,Dx,1]); */  /* Sord_w(x^2*Dx*Dy,[x,-1,Dx,1]); */
Line 346  def Sdegree(f,tower,level) {
Line 366  def Sdegree(f,tower,level) {
   f = Init(f);    f = Init(f);
   if (level <= 1) return(StotalDegree(f));    if (level <= 1) return(StotalDegree(f));
   i = Degree(f,es);    i = Degree(f,es);
 #ifdef TOTAL_STRATEGY  
   return(StotalDegree(f)+Sdegree(tower[level-2,i],tower,level-1));    return(StotalDegree(f)+Sdegree(tower[level-2,i],tower,level-1));
 #endif  
   /* Strategy must be compatible with ordering.  */  
   /* Weight vector must be non-negative, too.  */  
   /* See Sdegree, SgenerateTable, reductionTable. */  
   wd = Sord_w(f,ww);  
   return(wd+Sdegree(tower[level-2,i],tower,level-1));  
   
 }  }
   
 def SgenerateTable(tower) {  def SgenerateTable(tower) {
   local height, n,i,j, ans, ans_at_each_floor;    local height, n,i,j, ans, ans_at_each_floor;
   
     /*
     Print("SgenerateTable: tower=");Println(tower);
     sm1(" print_switch_status "); */
   height = Length(tower);    height = Length(tower);
   ans = NewArray(height);    ans = NewArray(height);
   for (i=0; i<height; i++) {    for (i=0; i<height; i++) {
Line 434  def SmaxOfStrategy(a) {
Line 451  def SmaxOfStrategy(a) {
 }  }
   
   
 def SlaScala(g) {  def SlaScala(g,opt) {
   local rf, tower, reductionTable, skel, redundantTable, bases,    local rf, tower, reductionTable, skel, redundantTable, bases,
         strategy, maxOfStrategy, height, level, n, i,          strategy, maxOfStrategy, height, level, n, i,
         freeRes,place, f, reducer,pos, redundant_seq,bettiTable,freeResV,ww,          freeRes,place, f, reducer,pos, redundant_seq,bettiTable,freeResV,ww,
Line 443  def SlaScala(g) {
Line 460  def SlaScala(g) {
   /* extern WeightOfSweyl; */    /* extern WeightOfSweyl; */
   ww = WeightOfSweyl;    ww = WeightOfSweyl;
   Print("WeightOfSweyl="); Println(WeightOfSweyl);    Print("WeightOfSweyl="); Println(WeightOfSweyl);
   rf = SresolutionFrameWithTower(g);    rf = SresolutionFrameWithTower(g,opt);
     Print("rf="); sm1_pmat(rf);
   redundant_seq = 1;   redundant_seq_ordinary = 1;    redundant_seq = 1;   redundant_seq_ordinary = 1;
   tower = rf[1];    tower = rf[1];
   
     Println("Generating reduction table which gives an order of reduction.");
     Print("WeghtOfSweyl="); Println(WeightOfSweyl);
     Print("tower"); Println(tower);
   reductionTable = SgenerateTable(tower);    reductionTable = SgenerateTable(tower);
     Print("reductionTable="); sm1_pmat(reductionTable);
   
   skel = rf[2];    skel = rf[2];
   redundantTable = SnewArrayOfFormat(rf[1]);    redundantTable = SnewArrayOfFormat(rf[1]);
   redundantTable_ordinary = SnewArrayOfFormat(rf[1]);    redundantTable_ordinary = SnewArrayOfFormat(rf[1]);
Line 467  def SlaScala(g) {
Line 491  def SlaScala(g) {
         Println([level,i]);          Println([level,i]);
         reductionTable_tmp[i] = -200000;          reductionTable_tmp[i] = -200000;
         if (reductionTable[level,i] == strategy) {          if (reductionTable[level,i] == strategy) {
            Print("Processing "); Print([level,i]);             Print("Processing [level,i]= "); Print([level,i]);
            Print("   Strategy = "); Println(strategy);             Print("   Strategy = "); Println(strategy);
            if (level == 0) {             if (level == 0) {
              if (IsNull(redundantTable[level,i])) {               if (IsNull(redundantTable[level,i])) {
Line 535  def SlaScala(g) {
Line 559  def SlaScala(g) {
     bases = Sbases_to_vec(bases,bettiTable[i]);      bases = Sbases_to_vec(bases,bettiTable[i]);
     freeResV[i] = bases;      freeResV[i] = bases;
   }    }
   return([freeResV, redundantTable,reducer,bettiTable,redundantTable_ordinary]);    return([freeResV, redundantTable,reducer,bettiTable,redundantTable_ordinary,rf]);
 }  }
   
 def SthereIs(reductionTable_tmp,strategy) {  def SthereIs(reductionTable_tmp,strategy) {
Line 661  def MonomialPart(f) {
Line 685  def MonomialPart(f) {
   sm1(" [(lmonom) f] gbext /FunctionValue set ");    sm1(" [(lmonom) f] gbext /FunctionValue set ");
 }  }
   
   /* WARNING:
     When you use SwhereInTower, you have to change gbList
     as below. Ofcourse, you should restrore the gbList
     SsetTower(StowerOf(tower,level));
     pos = SwhereInTower(syzHead,tower[level]);
   */
 def SwhereInTower(f,tower) {  def SwhereInTower(f,tower) {
   local i,n,p,q;    local i,n,p,q;
   if (f == Poly("0")) return(-1);    if (f == Poly("0")) return(-1);
Line 697  def SpairAndReduction(skel,level,ii,freeRes,tower,ww) 
Line 727  def SpairAndReduction(skel,level,ii,freeRes,tower,ww) 
   
   tower2 = StowerOf(tower,level-1);    tower2 = StowerOf(tower,level-1);
   SsetTower(tower2);    SsetTower(tower2);
     Println(["level=",level]);
     Println(["tower2=",tower2]);
   /** sm1(" show_ring ");   */    /** sm1(" show_ring ");   */
   
   gi = Stoes_vec(bases[i]);    gi = Stoes_vec(bases[i]);
Line 730  def SpairAndReduction(skel,level,ii,freeRes,tower,ww) 
Line 762  def SpairAndReduction(skel,level,ii,freeRes,tower,ww) 
   sj = sj*tmp[1]+t_syz[j];    sj = sj*tmp[1]+t_syz[j];
   t_syz[i] = si;    t_syz[i] = si;
   t_syz[j] = sj;    t_syz[j] = sj;
   
     SsetTower(StowerOf(tower,level));
   pos = SwhereInTower(syzHead,tower[level]);    pos = SwhereInTower(syzHead,tower[level]);
   
     SsetTower(StowerOf(tower,level-1));
   pos2 = SwhereInTower(tmp[0],tower[level-1]);    pos2 = SwhereInTower(tmp[0],tower[level-1]);
   ans = [tmp[0],t_syz,pos,pos2,vdeg,vdeg_reduced];    ans = [tmp[0],t_syz,pos,pos2,vdeg,vdeg_reduced];
   /* pos is the place to put syzygy at level. */    /* pos is the place to put syzygy at level. */
Line 843  def Sbases_to_vec(bases,size) {
Line 879  def Sbases_to_vec(bases,size) {
   return(newbases);    return(newbases);
 }  }
   
 def Sminimal(g) {  HelpAdd(["Sminimal",
   ["It constructs the V-minimal free resolution by LaScala's algorithm",
    "option: \"homogenized\" (no automatic homogenization ",
    "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);",
    "         Sweyl(\"x,y\",[[\"x\",-1,\"y\",-1,\"Dx\",1,\"Dy\",1]]);",
    "         b = ReParse(a[0]); sm1_pmat(b); ",
    "         IsExact_h(b,[x,y]):",
    "Note:  a[0] is the V-minimal resolution. a[3] is the Schreyer resolution."]]);
   
   def Sminimal(g,opt) {
   local r, freeRes, redundantTable, reducer, maxLevel,    local r, freeRes, redundantTable, reducer, maxLevel,
         minRes, seq, maxSeq, level, betti, q, bases, dr,          minRes, seq, maxSeq, level, betti, q, bases, dr,
         betti_levelplus, newbases, i, j,qq;          betti_levelplus, newbases, i, j,qq, tminRes;
   r = SlaScala(g);    if (Length(Arglist) < 2) {
        opt = null;
     }
     ScheckIfSchreyer("Sminimal:0");
     r = SlaScala(g,opt);
   /* Should I turn off the tower?? */    /* Should I turn off the tower?? */
     ScheckIfSchreyer("Sminimal:1");
   freeRes = r[0];    freeRes = r[0];
   redundantTable = r[1];    redundantTable = r[1];
   reducer = r[2];    reducer = r[2];
Line 904  def Sminimal(g) {
Line 959  def Sminimal(g) {
       }        }
     }      }
    }     }
    return([Stetris(minRes,redundantTable),     tminRes = Stetris(minRes,redundantTable);
           [ minRes, redundantTable, reducer,r[3],r[4]],r[0]]);     return([SpruneZeroRow(tminRes), tminRes,
             [ minRes, redundantTable, reducer,r[3],r[4]],r[0],r[5]]);
   /* r[4] is the redundantTable_ordinary */    /* r[4] is the redundantTable_ordinary */
   /* r[0] is the freeResolution */    /* r[0] is the freeResolution */
     /* r[5] is the skelton */
 }  }
   
   
Line 1040  def Sannfs2(f) {
Line 1097  def Sannfs2(f) {
   local p,pp;    local p,pp;
   p = Sannfs(f,"x,y");    p = Sannfs(f,"x,y");
   sm1(" p 0 get { [(x) (y) (Dx) (Dy)] laplace0 } map /p set ");    sm1(" p 0 get { [(x) (y) (Dx) (Dy)] laplace0 } map /p set ");
 /*  
   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]]);    Sweyl("x,y",[["x",-1,"y",-1,"Dx",1,"Dy",1]]);
   pp = Map(p,"Spoly");    pp = Map(p,"Spoly");
   return(Sminimal_v(pp));    return(Sminimal(pp));
   /* return(Sminimal(pp)); */  
 }  }
   
 /* Do not forget to turn on TOTAL_STRATEGY */  HelpAdd(["Sannfs2",
 def Sannfs2_laScala(f) {  ["Sannfs2(f) constructs the V-minimal free resolution for the weight (-1,1)",
   local p,pp;   "of the Laplace transform of the annihilating ideal of the polynomial f in x,y.",
   p = Sannfs(f,"x,y");   "See also Sminimal, Sannfs3.",
   /*   Do not make laplace transform.   "Example: a=Sannfs2(\"x^3-y^2\");",
     sm1(" p 0 get { [(x) (y) (Dx) (Dy)] laplace0 } map /p set ");   "         b=a[0]; sm1_pmat(b);",
     p = [p];   "         b[1]*b[0]:",
   */   "Example: a=Sannfs2(\"x*y*(x-y)*(x+y)\");",
   Sweyl("x,y",[["x",-1,"y",-1,"Dx",1,"Dy",1]]);   "         b=a[0]; sm1_pmat(b);",
   pp = Map(p[0],"Spoly");   "         b[1]*b[0]:"
   return(Sminimal(pp));  ]]);
 }  /* Some samples.
     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.
     a=Sannfs2("x^3-y^2-x");
     a=Sannfs2("x*y*(x-y)");
   */
   
   
 def Sannfs3(f) {  def Sannfs3(f) {
   local p,pp;    local p,pp;
   p = Sannfs(f,"x,y,z");    p = Sannfs(f,"x,y,z");
   sm1(" p 0 get { [(x) (y) (z) (Dx) (Dy) (Dz)] laplace0 } map /p set ");    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]]);    Sweyl("x,y,z",[["x",-1,"y",-1,"z",-1,"Dx",1,"Dy",1,"Dz",1]]);
   pp = Map(p,"Spoly");    pp = Map(p,"Spoly");
   return(Sminimal_v(pp));    return(Sminimal(pp));
 }  }
   
 /*  HelpAdd(["Sannfs3",
   The betti numbers of most examples are 2,1. (0-th and 1-th).  ["Sannfs3(f) constructs the V-minimal free resolution for the weight (-1,1)",
   a=Sannfs2("x*y*(x+y-1)"); ==> The betti numbers are 3, 2.   "of the Laplace transform of the annihilating ideal of the polynomial f in x,y,z.",
   a=Sannfs2("x^3-y^2-x");    : it causes an error. It should be fixed.   "See also Sminimal, Sannfs2.",
   a=Sannfs2("x*y*(x-y)");    : it causes an error. It should be fixed.   "Example: a=Sannfs3(\"x^3-y^2*z^2\");",
    "         b=a[0]; sm1_pmat(b);",
    "         b[1]*b[0]: b[2]*b[1]:"]]);
   
 */  
   
   
   /* 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.
   */
   
 /*  The below does not use LaScala-Stillman's algorithm. */  def CopyArray(m) {
 def Sschreyer(g) {    local ans,i,n;
   local rf, tower, reductionTable, skel, redundantTable, bases,    if (IsArray(m)) {
         strategy, maxOfStrategy, height, level, n, i,       n = Length(m);
         freeRes,place, f, reducer,pos, redundant_seq,bettiTable,freeResV,ww,       ans = NewArray(n);
         redundantTable_ordinary, redundant_seq_ordinary,       for (i=0; i<n; i++) {
         reductionTable_tmp,c2,ii,nn, m,ii, jj, reducerBase;         ans[i] = CopyArray(m[i]);
   /* extern WeightOfSweyl; */       }
   ww = WeightOfSweyl;       return(ans);
   Print("WeghtOfSweyl="); Println(WeightOfSweyl);    }else{
   rf = SresolutionFrameWithTower(g);       return(m);
   redundant_seq = 1;   redundant_seq_ordinary = 1;    }
   tower = rf[1];  }
   reductionTable = SgenerateTable(tower);  HelpAdd(["CopyArray",
   skel = rf[2];  ["It duplicates the argument array recursively.",
   redundantTable = SnewArrayOfFormat(rf[1]);   "Example: m=[1,[2,3]];",
   redundantTable_ordinary = SnewArrayOfFormat(rf[1]);   "         a=CopyArray(m); a[1] = \"Hello\";",
   reducer = SnewArrayOfFormat(rf[1]);   "         Println(m); Println(a);"]]);
   freeRes = SnewArrayOfFormat(rf[1]);  
   bettiTable = SsetBettiTable(rf[1],g);  
   
   height = Length(reductionTable);  def IsZeroVector(m) {
   for (level = 0; level < height; level++) {    local n,i;
       n = Length(reductionTable[level]);    n = Length(m);
       for (i=0; i<n; i++) {  
            Println([level,i]);  
            Print("Processing "); Print([level,i]);  
            if (level == 0) {  
              if (IsNull(redundantTable[level,i])) {  
                bases = freeRes[level];  
                /* Println(["At floor : GB=",i,bases,tower[0,i]]); */  
                pos = SwhereInGB(tower[0,i],rf[3,0]);  
                bases[i] = rf[3,0,pos];  
                /* redundantTable[level,i] = 0;  
                redundantTable_ordinary[level,i] = 0; */  
                freeRes[level] = bases;  
                /* Println(["GB=",i,bases,tower[0,i]]); */  
              }  
            }else{ /* level >= 1 */  
              if (IsNull(redundantTable[level,i])) {  
                bases = freeRes[level];  
                f = SpairAndReduction2(skel,level,i,freeRes,tower,  
                                       ww,redundantTable);  
                if (f[0] != Poly("0")) {  
                   place = f[3];  
                   /* (level-1, place) is the place for f[0],  
                      which is a newly obtained  GB. */  
 #ifdef ORDINARY  
                   redundantTable[level-1,place] = redundant_seq;  
                   redundant_seq++;  
 #else  
                   if (f[4] > f[5]) {  
                     /* Zero in the gr-module */  
                     Print("v-degree of [org,remainder] = ");  
                     Println([f[4],f[5]]);  
                     Print("[level,i] = "); Println([level,i]);  
                     redundantTable[level-1,place] = 0;  
                   }else{  
                     redundantTable[level-1,place] = redundant_seq;  
                     redundant_seq++;  
                   }  
 #endif  
                   redundantTable_ordinary[level-1,place]  
                      =redundant_seq_ordinary;  
                   redundant_seq_ordinary++;  
                   bases[i] = SunitOfFormat(place,f[1])-f[1];  /* syzygy */  
                   /* redundantTable[level,i] = 0;  
                   redundantTable_ordinary[level,i] = 0; */  
                   /* i must be equal to f[2], I think. Double check. */  
   
                   /* Correction Of Constant */  
                   /* Correction of syzygy */  
                   c2 = f[6];  /* or -f[6]?  Double check. */  
                   Print("c2="); Println(c2);  
                   nn = Length(bases);  
                   for (ii=0; ii<nn;ii++) {  
                      if ((ii != i) && (! IsNull(bases[ii]))) {  
                        m = Length(bases[ii]);  
                        for (jj=0; jj<m; jj++) {  
                          if (jj != place) {  
                            bases[ii,jj] = bases[ii,jj]*c2;  
                          }  
                        }  
                      }  
                   }  
   
                   Print("Old freeRes[level] = "); sm1_pmat(freeRes[level]);  
                   freeRes[level] = bases;  
                   Print("New freeRes[level] = "); sm1_pmat(freeRes[level]);  
   
                  /* Update the freeRes[level-1] */  
                   Print("Old freeRes[level-1] = "); sm1_pmat(freeRes[level-1]);  
                   bases = freeRes[level-1];  
                   bases[place] = f[0];  
                   freeRes[level-1] = bases;  
                   Print("New freeRes[level-1] = "); sm1_pmat(freeRes[level-1]);  
   
                   reducer[level-1,place] = f[1]-SunitOfFormat(place,f[1]);  
                    /* This reducer is different from that of SlaScala(). */  
   
                   reducerBasis = reducer[level-1];  
                   nn = Length(reducerBasis);  
                   for (ii=0; ii<nn;ii++) {  
                      if ((ii != place) && (! IsNull(reducerBasis[ii]))) {  
                        m = Length(reducerBasis[ii]);  
                        for (jj=0; jj<m; jj++) {  
                          if (jj != place) {  
                            reducerBasis[ii,jj] = reducerBasis[ii,jj]*c2;  
                          }  
                        }  
                      }  
                   }  
                   reducer[level-1] = reducerBasis;  
   
                }else{  
                   /* redundantTable[level,i] = 0; */  
                   bases = freeRes[level];  
                   bases[i] = f[1];  /* Put the syzygy. */  
                   freeRes[level] = bases;  
                }  
              }  /* end of level >= 1 */  
           }  
     } /* i loop */  
   
     /* Triangulate reducer */  
     if (level >= 1) {  
       Println(" ");  
       Print("Triangulating reducer at level "); Println(level-1);  
       Println("freeRes[level]="); sm1_pmat(freeRes[level]);  
       reducerBase = reducer[level-1];  
       Print("reducerBase=");  Println(reducerBase);  
       Println("Compare freeRes[level] and reducerBase (put -1)");  
       m = Length(reducerBase);  
       for (ii=m-1; ii>=0; ii--) {  
         if (!IsNull(reducerBase[ii])) {  
            for (jj=ii-1; jj>=0; jj--) {  
              if (!IsNull(reducerBase[jj])) {  
               if (!IsZero(reducerBase[jj,ii])) {  
                 /* reducerBase[ii,ii] should be always constant. */  
                 reducerBase[jj] = reducerBase[ii,ii]*reducerBase[jj]-reducerBase[jj,ii]*reducerBase[ii];  
               }  
              }  
            }  
          }  
        }  
        Println("New reducer");  
        sm1_pmat(reducerBase);  
        reducer[level-1] = reducerBase;  
     }  
   
   } /* level loop */  
   n = Length(freeRes);  
   freeResV = SnewArrayOfFormat(freeRes);  
   for (i=0; i<n; i++) {    for (i=0; i<n; i++) {
     bases = freeRes[i];      if (!IsZero(m[i])) {
     bases = Sbases_to_vec(bases,bettiTable[i]);        return(false);
     freeResV[i] = bases;      }
   }    }
     return(true);
   }
   
   /* Mark the non-redundant elements. */  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++) {    for (i=0; i<n; i++) {
     m = Length(redundantTable[i]);      base = minRes[i];
     for (jj=0; jj<m; jj++) {      m = Length(base);
       if (IsNull(redundantTable[i,jj])) {      if (i != n-1) {
         redundantTable[i,jj] = 0;        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) {
   return([freeResV, redundantTable,reducer,bettiTable,redundantTable_ordinary]);    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 SpairAndReduction2(skel,level,ii,freeRes,tower,ww,redundantTable) {  def ToString_array(p) {
   local i, j, myindex, p, bases, tower2, gi, gj,    local ans;
        si, sj, tmp, t_syz, pos, ans, ssp, syzHead,pos2,    if (IsArray(p)) {
        vdeg,vdeg_reduced,n,c2;      ans = Map(p,"ToString_array");
   Println("SpairAndReduction2 : -------------------------");    }else{
       ans = ToString(p);
   if (level < 1) Error("level should be >= 1 in SpairAndReduction.");  
   p = skel[level,ii];  
   myindex = p[0];  
   i = myindex[0]; j = myindex[1];  
   bases = freeRes[level-1];  
   Println(["p and bases ",p,bases]);  
   if (IsNull(bases[i]) || IsNull(bases[j])) {  
     Println([level,i,j,bases[i],bases[j]]);  
     Error("level, i, j : bases[i], bases[j]  must not be NULL.");  
   }    }
     return(ans);
   }
   
   tower2 = StowerOf(tower,level-1);  /* sm1_res_div([[x],[y]],[[x^2],[x*y],[y^2]],[x,y]): */
   SsetTower(tower2);  
   /** sm1(" show_ring ");   */  
   
   gi = Stoes_vec(bases[i]);  def sm1_res_div(I,J,V) {
   gj = Stoes_vec(bases[j]);    I = ToString_array(I);
     J = ToString_array(J);
     V = ToString_array(V);
     sm1(" [[ I J]  V ] res*div /FunctionValue set ");
   }
   
   ssp = Sspolynomial(gi,gj);  /* It has not yet been working */
   si = ssp[0,0];  def sm1_res_kernel_image(m,n,v) {
   sj = ssp[0,1];    m = ToString_array(m);
   syzHead = si*es^i;    n = ToString_array(n);
   /* This will be the head term, I think. But, double check. */    v = ToString_array(v);
   Println([si*es^i,sj*es^j]);    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 ");
   }
   
   Print("[gi, gj] = "); Println([gi,gj]);  
   sm1(" [(Homogenize)] system_variable message ");  
   Print("Reduce the element "); Println(si*gi+sj*gj);  
   Print("by  "); Println(bases);  
   
   tmp = Sreduction(si*gi+sj*gj, bases);  def sm1_gb(f,v) {
     f =ToString_array(f);
     v = ToString_array(v);
     sm1(" [f v] gb /FunctionValue set ");
   }
   
   Print("result is "); Println(tmp);  
   if (!IsZero(tmp[0])) {  
     Print("Error: base = ");  
     Println(Map(bases,"Stoes_vec"));  
     Error("SpairAndReduction2: the remainder should be zero. See tmp. tower2. show_ring.");  
   }  
   t_syz = tmp[2];  
   si = si*tmp[1]+t_syz[i];  
   sj = sj*tmp[1]+t_syz[j];  
   t_syz[i] = si;  
   t_syz[j] = sj;  
   
   c2 = null;  def SisComplex(a) {
   /* tmp[0] must be zero */    local n,i,j,k,b,p,q;
   n = Length(t_syz);    n = Length(a);
   for (i=0; i<n; i++) {    for (i=0; i<n-1; i++) {
      if (IsConstant(t_syz[i])){      if (Length(a[i+1]) != 0) {
       if (!IsZero(t_syz[i])) {        b = a[i+1]*a[i];
        if (IsNull(redundantTable[level-1,i])) {        p = Length(b); q = Length(b[0]);
          /* i must equal to pos2 below. */        for (j=0; j<p; j++) {
          c2 = -t_syz[i];          for (k=0; k<q; k++) {
          tmp[0] = c2*Stoes_vec(freeRes[level-1,i]);            if (!IsZero(b[j,k])) {
          t_syz[i] = 0;               Print("Is is not complex at ");
          /* tmp[0] = t_syz . g */               Println([i,j,k]);
          /* break; does not work. Use */               return(false);
          i = n;            }
        }          }
       }        }
      }      }
   }    }
     return(true);
   }
   
   /* This is essential part for V-minimal resolution. */  def IsExact_h(c,v) {
   /* vdeg = SvDegree(si*gi+sj*gj,tower,level-1,ww); */    local a;
   vdeg = SvDegree(si*gi,tower,level-1,ww);    v = ToString_array(v);
   vdeg_reduced = SvDegree(tmp[0],tower,level-1,ww);    a = [c,v];
   Print("vdegree of the original = "); Println(vdeg);    sm1(a," isExact_h /FunctionValue set ");
   Print("vdegree of the remainder = "); Println(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];  
   /* pos is the place to put syzygy at level. */  
   /* pos2 is the place to put a new GB at level-1. */  
   Println(ans);  
   Println("  ");  
   return(ans);  
 }  }
   HelpAdd(["IsExact_h",
   ["IsExact_h(complex,var): bool",
    "It checks the given complex is exact or not in D<h> (homogenized Weyl algebra)",
    "cf. ReParse"
   ]]);
   
 def Sminimal_v(g) {  def ReParse(a) {
   local r, freeRes, redundantTable, reducer, maxLevel,    local c;
         minRes, seq, maxSeq, level, betti, q, bases, dr,    if (IsArray(a)) {
         betti_levelplus, newbases, i, j,qq;      c = Map(a,"ReParse");
   r = Sschreyer(g);    }else{
   sm1_pmat(r);      sm1(a," toString . /c set");
   Debug_Sminimal_v = r;  
   Println(" Return value of Schreyer(g) is set to Debug_Sminimal_v");  
   /* Should I turn off the tower?? */  
   freeRes = r[0];  
   redundantTable = r[1];  
   reducer = r[2];  
   minRes = SnewArrayOfFormat(freeRes);  
   seq = 0;  
   maxSeq = SgetMaxSeq(redundantTable);  
   maxLevel = Length(freeRes);  
   for (level = 0; level < maxLevel; level++) {  
     minRes[level] = freeRes[level];  
   }    }
   for (level = 0; level < maxLevel; level++) {    return(c);
       betti = Length(freeRes[level]);  }
       for (q = betti-1; q>=0; q--) {  HelpAdd(["ReParse",
         if (redundantTable[level,q] > 0) {  ["Reparse(obj): obj",
           Print("[seq,level,q]="); Println([seq,level,q]);   "It parses the given object in the current ring.",
           if (level < maxLevel-1) {   "Outputs from SlaScala, Sschreyer may cause a trouble in other functions,",
             bases = freeRes[level+1];   "because it uses the Schreyer order.",
             dr = reducer[level,q];   "In this case, ReParse the outputs from these functions.",
             /* dr[q] = -1;  We do not need this in our reducer format. */   "cf. IsExaxt_h"
             /* dr[q] should be a non-zero constant. */  ]]);
             newbases = SnewArrayOfFormat(bases);  
             betti_levelplus = Length(bases);  
             /*  
                bases[i,j] ---> bases[i,j]+bases[i,q]*dr[j]  
             */  
             for (i=0; i<betti_levelplus; i++) {  
               newbases[i] = dr[q]*bases[i] - bases[i,q]*dr;  
             }  
             Println(["level, q =", level,q]);  
             Println("bases="); sm1_pmat(bases);  
             Println("dr="); sm1_pmat(dr);  
             Println("newbases="); sm1_pmat(newbases);  
             minRes[level+1] = newbases;  
             freeRes = minRes;  
 #ifdef DEBUG  
             for (qq=q; qq<betti; qq++) {  
                 for (i=0; i<betti_levelplus; i++) {  
                   if ((!IsZero(newbases[i,qq])) && (redundantTable[level,qq] >0)) {  
                     Println(["[i,qq]=",[i,qq]," is not zero in newbases."]);  
                     Print("redundantTable ="); sm1_pmat(redundantTable[level]);  
                     Error("Stop in Sminimal for debugging.");  
                   }  
                 }  
             }  
 #endif  
           }  
         }  
       }  
    }  
    return([Stetris(minRes,redundantTable),  
           [ 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 */  def ScheckIfSchreyer(s) {
     local ss;
     sm1(" (report) (grade) switch_function /ss set ");
     if (ss != "module1v") {
        Print("ScheckIfSchreyer: from "); Println(s);
        Error("grade is not module1v");
     }
     /*
     sm1(" (report) (mmLarger) switch_function /ss set ");
     if (ss != "tower") {
        Print("ScheckIfSchreyer: from "); Println(s);
        Error("mmLarger is not tower");
     }
     */
     sm1(" [(Schreyer)] system_variable (universalNumber) dc /ss set ");
     if (ss != 1) {
        Print("ScheckIfSchreyer: from "); Println(s);
        Error("Schreyer order is not set.");
     }
     /* More check will be necessary. */
     return(true);
   }
   
Legend:
Removed from v.1.9  
changed lines
  Added in v.1.18
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>