Changeset 11d9d00 in git

Timestamp:

Dec 15, 2014, 1:19:16 AM (9 years ago)

Author:

Stephan Oberfranz <oberfran@…>

Branches:

(u'spielwiese', 'd0474371d8c5d8068ab70bfb42719c97936b18a6')

Children:

4083faab6546fc5c3396c90683e190ab3b4d1327

Parents:

8af63a71de0015f0413204e1a7a8620a8d37cc7a350269c461fd0afbb2c4d79cc7d38d2793207b12

Message:

---

Merge branch 'spielwiese' of github.com:Singular/Sources into spielwiese

Files:

• Singular/LIB/grwalk.lib (modified) (9 diffs)
• Singular/LIB/hess.lib (modified) (1 diff)
• Singular/LIB/modwalk.lib (modified) (20 diffs, 1 prop)
• Singular/LIB/normal.lib (modified) (2 diffs)
• Singular/LIB/primdec.lib (modified) (9 diffs)
• Singular/LIB/rwalk.lib (modified) (11 diffs, 1 prop)
• Singular/LIB/schreyer.lib (modified) (101 diffs)
• Singular/LIB/standard.lib (modified) (1 diff)
• Singular/LIB/swalk.lib (modified) (1 prop)
• Singular/Makefile.am (modified) (2 diffs)
• Singular/extra.cc (modified) (2 diffs)
• Singular/ipshell.cc (modified) (5 diffs)
• Singular/number2.cc (modified) (1 diff)
• Singular/walk.cc (modified) (141 diffs, 1 prop)
• Singular/walk.h (modified) (1 diff, 1 prop)
• Tst/Long/bug_tr677.res.gz.uu (added)
• Tst/Long/bug_tr677.stat (added)
• Tst/Long/bug_tr677.tst (added)
• Tst/Long/ok_l2.lst (modified) (1 diff)
• Tst/Long/primdec_l.res.gz.uu (modified) (1 diff)
• Tst/Manual/goodBasis.res.gz.uu (modified) (1 diff)
• doc/reference.doc (modified) (previous)
• dox/Doxyfile.in (modified) (1 diff)
• kernel/GBEngine/kstd1.cc (modified) (15 diffs)
• kernel/GBEngine/kstd2.cc (modified) (6 diffs)
• kernel/ideals.cc (modified) (1 diff)
• kernel/structs.h (modified) (1 diff)
• libpolys/coeffs/coeffs.h (modified) (3 diffs)
• libpolys/coeffs/gnumpfl.cc (modified) (1 diff)
• libpolys/coeffs/modulop.cc (modified) (1 diff)
• libpolys/coeffs/rintegers.cc (modified) (71 diffs)
• libpolys/coeffs/rintegers.h (modified) (1 diff)
• libpolys/coeffs/rmodulo2m.cc (modified) (33 diffs)
• libpolys/coeffs/rmodulo2m.h (modified) (3 diffs)
• libpolys/coeffs/rmodulon.cc (modified) (44 diffs)
• libpolys/coeffs/rmodulon.h (modified) (1 diff)
• libpolys/polys/flintconv.cc (modified) (6 diffs)
• libpolys/polys/flintconv.h (modified) (1 diff)
• libpolys/polys/monomials/ring.h (modified) (1 diff)

Singular/LIB/grwalk.lib

@@ -255 +255 @@
 }
 
-proc gwalk(ideal Go, list #)
-"SYNTAX: gwalk(ideal i);
-         gwalk(ideal i, intvec v, intvec w);
+proc gwalk(ideal Go, int reduction,int printout, list #)
+"SYNTAX: gwalk(ideal i, int reduction, int printout);
+         gwalk(ideal i, int reduction, int printout, intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
@@ -284 +284 @@
    //print("//** help ring = " + string(basering));
    ideal G = fetch(xR, Go);
-   G = system("Mwalk", G, curr_weight, target_weight,basering);
+   G = system("Mwalk", G, curr_weight, target_weight,basering,reduction,printout);
 
    setring xR;
@@ -300 +300 @@
   ring r = 32003,(z,y,x), lp;
   ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
-  gwalk(I);
+  gwalk(I,0,1);
 }
 
@@ -346 +346 @@
 }
 
-proc fwalk(ideal Go, list #)
-"SYNTAX: fwalk(ideal i);
-         fwalk(ideal i, intvec v, intvec w);
+proc fwalk(ideal Go, int reduction, int printout, list #)
+"SYNTAX: fwalk(ideal i,int reductioin);
+         fwalk(ideal i, int reduction intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal w.r.t. the
@@ -372 +372 @@
 
    ideal G = fetch(xR, Go);
-   G = system("Mfwalk", G, curr_weight, target_weight);
+   G = system("Mfwalk", G, curr_weight, target_weight, reduction, printout);
 
    setring xR;
@@ -387 +387 @@
     ring r = 32003,(z,y,x), lp;
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
-    fwalk(I);
+    int reduction = 1;
+    int printout = 1;
+    fwalk(I,reduction,printout);
 }
 
@@ -437 +439 @@
 }
 
-proc pwalk(ideal Go, int n1, int n2, list #)
-"SYNTAX: pwalk(int d, ideal i, int n1, int n2);
-         pwalk(int d, ideal i, int n1, int n2, intvec v, intvec w);
+proc pwalk(ideal Go, int n1, int n2, int reduction, int printout, list #)
+"SYNTAX: pwalk(int d, ideal i, int n1, int n2, int reduction, int printout);
+         pwalk(int d, ideal i, int n1, int n2, int reduction, int printout, intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
@@ -477 +479 @@
   ideal G = fetch(xR, Go);
 
-  G = system("Mpwalk", G, n1, n2, curr_weight, target_weight,nP);
+  G = system("Mpwalk",G,n1,n2,curr_weight,target_weight,nP,reduction,printout);
  
   setring xR;
@@ -492 +494 @@
     ring r = 32003,(z,y,x), lp;
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
-    //I = std(I);
-    //ring rr = 32003,(z,y,x),lp;
-    //ideal I = fetch(r,I);
-    pwalk(I,2,2);
+    int reduction = 1;
+    int printout = 2;
+    pwalk(I,2,2,reduction,printout);
 }
 

Singular/LIB/hess.lib

@@ -1799 +1799 @@
 
         ring r_ext=(char(basering),@a),(x,y,z),lp;
+        poly aux=imap(base_r,aux);
+        minpoly=number(subst(aux,x,@a));
         poly F=imap(r_auxz,F);
         poly f_xz=subst(F,y,1);
-        poly aux=imap(base_r,aux);
-        minpoly=number(subst(aux,x,@a));
         map phi=r_ext,x+@a,0,z;
         poly f_origin=phi(f_xz);

Singular/LIB/modwalk.lib

@@ -16 +16 @@
 
 PROCEDURES:
+modpWalk(ideal,int,int,int[,int,int,int,int])    standard basis conversion of I in prime characteristic
 modWalk(ideal,int,int[,int,int,int,int]);        standard basis conversion of I using modular methods (chinese remainder)
 ";
@@ -29 +30 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-static proc modpWalk(def II, int p, int variant, list #)
+proc modpWalk(def II, int p, int variant, int reduction, list #)
 "USAGE:  modpWalk(I,p,#); I ideal, p integer, variant integer
 ASSUME:  If size(#) > 0, then 
@@ -80 +81 @@
     }
   }
-
-//-------------------------  make i homogeneous  -----------------------------
-  if(!mixedTest() && !h)
-  {
-    if(!((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg))
-    {
-      if(!((order == "simple") || (sizerl > 4)))
-      {
-        list rl@r = ringlist(@r);
-        nvar@r = nvars(@r);      
-        intvec w;
-        for(k = 1; k <= nvar@r; k++)
-        {
-          w[k] = deg(var(k));
-        }
-        w[nvar@r + 1] = 1;
-        rl@r[2][nvar@r + 1] = "homvar";
-        rl@r[3][2][2] = w;
-        def HomR = ring(rl@r);
-        setring HomR;
-        ideal i = imap(@r, i);
-        i = homog(i, homvar);
-      }
-    }
-  }
-
 //-------------------------  compute a standard basis mod p  -----------------------------
-
   if(variant == 1)
   {
     if(size(#)>0)
     {
-      i = rwalk(i,radius,pert_deg,#);
-     // rwalk(i,radius,pert_deg,#); std(i);
-    }
-    else
-    {
-      i = rwalk(i,radius,pert_deg);
+      i = rwalk(i,radius,pert_deg,reduction,#);
+    }
+    else
+    {
+      i = rwalk(i,radius,pert_deg,reduction);
     }
   }
@@ -124 +97 @@
     if(size(#) == 2)
     {
-      i = gwalk(i,#);
-    }
-    else
-    {
-      i = gwalk(i);
+      i = gwalk(i,reduction,#);
+    }
+    else
+    {
+      i = gwalk(i,reduction);
     }
   }
@@ -135 +108 @@
     if(size(#) == 2)
     {
-      i = frandwalk(i,radius,#);
-    }
-    else
-    {
-      i = frandwalk(i,radius);
+      i = frandwalk(i,radius,reduction,#);
+    }
+    else
+    {
+      i = frandwalk(i,radius,reduction);
     }
   }
@@ -157 +130 @@
     if(size(#) == 2)
     {
-     i=prwalk(i,radius,pert_deg,pert_deg,#);
-    }
-    else
-    {
-      i=prwalk(i,radius,pert_deg,pert_deg);
+     i=prwalk(i,radius,pert_deg,pert_deg,reduction,#);
+    }
+    else
+    {
+      i=prwalk(i,radius,pert_deg,pert_deg,reduction);
     }
   }
@@ -168 +141 @@
     if(size(#) == 2)
     {
-      i=pwalk(i,pert_deg,pert_deg,#);
-    }
-    else
-    {
-      i=pwalk(i,pert_deg,pert_deg);
-    }
-  }
-  
-  if(!mixedTest() && !h)
-  {
-    if(!((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg))
-    {
-      if(!((order == "simple") || (sizerl > 4)))
-      {
-        i = subst(i, homvar, 1);
-        i = simplify(i, 34);
-        setring @r;
-        i = imap(HomR, i);
-        i = interred(i);
-        kill HomR;
-      }
-    }
-  }
+      i=pwalk(i,pert_deg,pert_deg,reduction,#);
+    }
+    else
+    {
+      i=pwalk(i,pert_deg,pert_deg,reduction);
+    }
+  }
+
   setring R0;
   return(list(fetch(@r,i),p));
@@ -204 +162 @@
   ring ra = 0,x(1..4),(a(a),lp);
   ideal I = std(cyclic(4));
+  int reduction = 1;
   ring rb = 0,x(1..4),(a(b),lp);
   ideal I = imap(ra,I);
-  modpWalk(I,p,1,a,b);
+  modpWalk(I,p,1,reduction,a,b);
   std(I);
 }
@@ -212 +171 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-proc modWalk(def II, int variant, list #)
+proc modWalk(def II, int variant, int reduction, list #)
 "USAGE:  modWalk(II); II ideal or list(ideal,int)
 ASSUME:  If variant = 
@@ -487 +446 @@
   if(n2 > 4)
   {
-  //  L[5] = prime(random(an,en));
+    L[5] = prime(random(an,en));
   }
   if(printlevel >= 10)
@@ -504 +463 @@
     for(i=1; i<=size(L); i++)
     {
-      Arguments[i] = list(II,L[i],variant,list(curr_weight,target_weight));
+      Arguments[i] = list(II,L[i],variant,reduction,list(curr_weight,target_weight));
     }
   }
@@ -511 +470 @@
     for(i=1; i<=size(L); i++)
     {
-      Arguments[i] = list(II,L[i],variant);
+      Arguments[i] = list(II,L[i],variant,reduction);
     }
   }
@@ -528 +487 @@
 //-------------------  Now all leading ideals are the same  --------------------
 //-------------------  Lift results to basering via farey  ---------------------
-
     tt = timer; rt = rtimer;
     N = T2[1];
@@ -545 +503 @@
 
 //----------------  Test if we already have a standard basis of I --------------
-
     tt = timer; rt = rtimer;
-    pTest = pTestSB(I,J,L,variant);
-    //pTest = primeTestSB(I,J,L,variant);
+    pTest = primeTest(J, prime(random(1000000000,2134567879)));
     if(printlevel >= 10)
     {
@@ -596 +552 @@
     }
 //--------------  We do not already have a standard basis of I, therefore do the main computation for more primes  --------------
-
     T1 = H;
     T2 = N;
@@ -613 +568 @@
       for(i=j; i<=size(L); i++)
       {
-        //Arguments[i-j+1] = list(II,L[i],variant,list(curr_weight,target_weight));
-        Arguments[size(Arguments)+1] = list(II,L[i],variant,list(curr_weight,target_weight));
+        Arguments[size(Arguments)+1] = list(II,L[i],variant,reduction,list(curr_weight,target_weight));
       }
     }
@@ -621 +575 @@
       for(i=j; i<=size(L); i++)
       {
-        //Arguments[i-j+1] = list(II,L[i],variant);
-        Arguments[size(Arguments)+1] = list(II,L[i],variant);
+        Arguments[size(Arguments)+1] = list(II,L[i],variant,reduction);
       }
     }
@@ -632 +585 @@
     for(i=1; i<=size(PP); i++)
     {
-      //P[size(P) + 1] = PP[i];
       T1[size(T1) + 1] = PP[i][1];
       T2[size(T2) + 1] = bigint(PP[i][2]);
@@ -649 +601 @@
   echo = 2;
   ring R=0,(x,y,z),lp;
-  ideal I=-x+y2z-z,xz+1,x2+y2-1;
-  // I is a standard basis in dp
-  ideal J = modWalk(I,1);
+  ideal I= y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
+  int reduction = 0;
+  ideal J = modWalk(I,1,1);
   J;
 }
@@ -772 +724 @@
   return(J);
 }
-//////////////////////////////////////////////////////////////////////////////////
-static proc primeTestSB(def II, ideal J, list L, int variant, list #)
-"USAGE:  primeTestSB(I,J,L,variant,#); I,J ideals, L intvec of primes, variant int
-RETURN:  1 (resp. 0) if for a randomly chosen prime p that is not in L
-         J mod p is (resp. is not) a standard basis of I mod p
-EXAMPLE: example primeTestSB; shows an example
-"
-{
-if(typeof(II) == "ideal")
-  {
-  ideal I = II;
-  int radius = 2;
-  }
-if(typeof(II) == "list")
-  {
-  ideal I = II[1];
-  int radius = II[2];
-  }
-
-int i,j,k,p;
-def R = basering;
-list r = ringlist(R);
-
-while(!j)
-  {
-  j = 1;
-  p = prime(random(1000000000,2134567879));
-  for(i = 1; i <= size(L); i++)
-    {
-    if(p == L[i])
-      {
-      j = 0;
-      break;
-      }
-    }
-  if(j)
-    {
-    for(i = 1; i <= ncols(I); i++)
-      {
-      for(k = 2; k <= size(I[i]); k++)
-        {
-        if((denominator(leadcoef(I[i][k])) mod p) == 0)
-          {
-          j = 0;
-          break;
-          }
-        }
-      if(!j)
-        {
-        break;
-        }
-      }
-    }
-  if(j)
-    {
-    if(!primeTest(I,p))
-      {
-      j = 0;
-      }
-    }
-  }
-r[1] = p;
-def @R = ring(r);
-setring @R;
-ideal I = imap(R,I);
-ideal J = imap(R,J);
-attrib(J,"isSB",1);
-
-int t = timer;
-j = 1;
-if(isIncluded(I,J) == 0)
-  {
-  j = 0;
-  }
-if(printlevel >= 11)
-  {
-  "isIncluded(I,J) takes "+string(timer - t)+" seconds";
-  "j = "+string(j);
-  }
-t = timer;
-if(j)
-  {
-  if(size(#) > 0)
-    {
-    ideal K = modpWalk(I,p,variant,#)[1];
-    }
-  else
-    {
-    ideal K = modpWalk(I,p,variant)[1];
-    }
-  t = timer;
-  if(isIncluded(J,K) == 0)
-    {
-    j = 0;
-    }
-  if(printlevel >= 11)
-    {
-    "isIncluded(K,J) takes "+string(timer - t)+" seconds";
-    "j = "+string(j);
-    }
-  }
-setring R;
-
-return(j);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   intvec L = 2,3,5;
-   ring r = 0,(x,y,z),lp;
-   ideal I = x+1,x+y+1;
-   ideal J = x+1,y;
-   primeTestSB(I,I,L,1);
-   primeTestSB(I,J,L,1);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static proc pTestSB(ideal I, ideal J, list L, int variant, list #)
-"USAGE:  pTestSB(I,J,L,variant,#); I,J ideals, L intvec of primes, variant int
-RETURN:  1 (resp. 0) if for a randomly chosen prime p that is not in L
-         J mod p is (resp. is not) a standard basis of I mod p
-EXAMPLE: example pTestSB; shows an example
-"
-{
-   int i,j,k,p;
-   def R = basering;
-   list r = ringlist(R);
-
-   while(!j)
-   {
-      j = 1;
-      p = prime(random(1000000000,2134567879));
-      for(i = 1; i <= size(L); i++)
-      {
-         if(p == L[i]) { j = 0; break; }
-      }
-      if(j)
-      {
-         for(i = 1; i <= ncols(I); i++)
-         {
-            for(k = 2; k <= size(I[i]); k++)
-            {
-               if((denominator(leadcoef(I[i][k])) mod p) == 0) { j = 0; break; }
-            }
-            if(!j){ break; }
-         }
-      }
-      if(j)
-      {
-         if(!primeTest(I,p)) { j = 0; }
-      }
-   }
-   r[1] = p;
-   def @R = ring(r);
-   setring @R;
-   ideal I = imap(R,I);
-   ideal J = imap(R,J);
-   attrib(J,"isSB",1);
-
-   int t = timer;
-   j = 1;
-   if(isIncluded(I,J) == 0) { j = 0; }
-
-   if(printlevel >= 11)
-   {
-      "isIncluded(I,J) takes "+string(timer - t)+" seconds";
-      "j = "+string(j);
-   }
-
-   t = timer;
-   if(j)
-   {
-      if(size(#) > 0)
-      {
-         ideal K = modpStd(I,p,variant,#[1])[1];
-      }
-      else
-      {
-         ideal K = groebner(I);
-      }
-      t = timer;
-      if(isIncluded(J,K) == 0) { j = 0; }
-
-      if(printlevel >= 11)
-      {
-         "isIncluded(J,K) takes "+string(timer - t)+" seconds";
-         "j = "+string(j);
-      }
-   }
-   setring R;
-   return(j);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   intvec L = 2,3,5;
-   ring r = 0,(x,y,z),dp;
-   ideal I = x+1,x+y+1;
-   ideal J = x+1,y;
-   pTestSB(I,I,L,2);
-   pTestSB(I,J,L,2);
-}
+
 ////////////////////////////////////////////////////////////////////////////////
 static proc mixedTest()

Singular/LIB/normal.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
-version="version normal.lib 4.0.0.0 Jun_2013 "; // $Id$
+version="version normal.lib 4.0.1.1 Dec_2014 "; // $Id$
 category="Commutative Algebra";
 info="
@@ -2329 +2329 @@
          execute("ring Rhelp=("+charstr(R0)+"),(@s),dp;");
       }
-      execute("minpoly = "+smp+";");
+      if (smp!="0")
+      { execute("minpoly = "+smp+";");}
       def newR=R+Rhelp;
       setring newR;

Singular/LIB/primdec.lib

@@ -2685 +2685 @@
    }
 //---Ende Provisorium
-   string mp="poly p="+string(minpoly)+";";
+   string mp="poly @p="+string(minpoly)+";";
    string gnir="ring RH="+string(char(R))+",("+varstr(R)+","+string(par(1))
                 +"),dp;";
@@ -2697 +2697 @@
      if(i[j]!=I[j]){break;}
    }
-   if((j>ncols(i))&&(deg(p)==1))
+   if((j>ncols(i))&&(deg(@p)==1))
    {
      setring R;
@@ -2709 +2709 @@
    else
    {
-      i=i,p;
+      i=i,@p;
    }
    list pr;
@@ -2726 +2726 @@
       pr=minAssPrimes(i);
    }
+
    if(n<nvars(basering))
    {
@@ -2747 +2748 @@
       list pr=imap(RH,pr);
    }
+
    list re;
    if(w==2)
@@ -2828 +2830 @@
   }
   homo=homog(i);
-  if(homo==1)
+  if(homo)
   {
     if(attrib(i,"isSB")!=1)
@@ -4174 +4176 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
-
 static proc simplifyIdeal(ideal i)
 {
   ASSUME(1, hasFieldCoefficient(basering) );
-  ASSUME(1, not isQuotientRing(basering) ) ;
   ASSUME(1, hasGlobalOrdering(basering) ) ;
 
   def r=basering;
+
+  ideal iwork=i;
+  ideal imap2=maxideal(1);
 
   int j,k;
   map phi;
   poly p;
-
-  ideal iwork=i;
   ideal imap1=maxideal(1);
-  ideal imap2=maxideal(1);
-
-
-  for(j=1;j<=nvars(basering);j++)
-  {
-    for(k=1;k<=size(i);k++)
+  // first try: very simple substitutions
+  intvec tested=0:nvars(r);
+  for(j=1;j<=nvars(r);j++)
+  {
+    for(k=1;k<=ncols(i);k++)
     {
       if(deg(iwork[k]/var(j))==0)
       {
         p=-1/leadcoef(iwork[k]/var(j))*iwork[k];
-        imap1[j]=p+2*var(j);
-        phi=r,imap1;
-        iwork=phi(iwork);
-        iwork=subst(iwork,var(j),0);
-        iwork[k]=var(j);
-        imap1=maxideal(1);
-        imap2[j]=-p;
-        break;
+        if(size(p)<=2)
+        {
+          tested[j]=1;
+          imap1[j]=p+2*var(j);
+          phi=r,imap1;
+          iwork=phi(iwork);
+          iwork=subst(iwork,var(j),0);
+          iwork[k]=var(j);
+          imap1=maxideal(1);
+          imap2[j]=-p;
+          break;
+        }
+      }
+    }
+  }
+  // second try: substitutions not so simple
+  for(j=1;j<=nvars(r);j++)
+  {
+    if (tested[j]==0)
+    {
+      for(k=1;k<=ncols(i);k++)
+      {
+        if(deg(iwork[k]/var(j))==0)
+        {
+          p=-1/leadcoef(iwork[k]/var(j))*iwork[k];
+          imap1[j]=p+2*var(j);
+          phi=r,imap1;
+          iwork=phi(iwork);
+          iwork=subst(iwork,var(j),0);
+          iwork[k]=var(j);
+          imap1=maxideal(1);
+          imap2[j]=-p;
+          break;
+        }
       }
     }
@@ -5863 +5889 @@
   ASSUME(0, not isQuotientRing(basering) ) ;
   dbprint(printlevel - voice, "Radical, version 2006.05.08");
+  if(size(i) == 0){return(ideal(0));}
   if(attrib(basering,"global")!=1)
   {
@@ -5877 +5904 @@
       return(j);
   }
-  if(size(i) == 0){return(ideal(0));}
   int j;
   def P0 = basering;

Singular/LIB/rwalk.lib

@@ -10 +10 @@
 rwalk(ideal,int,int[,intvec,intvec]);   standard basis of ideal via Random Walk algorithm
 rwalk(ideal,int[,intvec,intvec]);       standard basis of ideal via Random Perturbation Walk algorithm
-frwalk(ideal,int[,intvec,intvec]);      standard basis of ideal via Random Fractal Walk algorithm
+frandwalk(ideal,int[,intvec,intvec]);      standard basis of ideal via Random Fractal Walk algorithm
 ";
 
@@ -141 +141 @@
  * Random Walk  *
  ****************/
-proc rwalk(ideal Go, int radius, int pert_deg, list #)
+proc rwalk(ideal Go, int radius, int pert_deg, int reduction, int printout, list #)
 "SYNTAX: rwalk(ideal i, int radius);
          if size(#)>0 then rwalk(ideal i, int radius, intvec v, intvec w);
+         intermediate Groebner bases are not reduced if reduction = 0
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
@@ -178 +179 @@
 
 ideal G = fetch(xR, Go);
-G = system("Mrwalk", G, curr_weight, target_weight, radius, pert_deg, basering);
+G = system("Mrwalk", G, curr_weight, target_weight, radius, pert_deg, reduction, printout);
 
 setring xR;
@@ -196 +197 @@
   int radius = 1;
   int perturb_deg = 2;
-  rwalk(I,radius,perturb_deg);
+  int reduction = 0;
+  int printout = 1;
+  rwalk(I,radius,perturb_deg,reduction,printout);
 }
 
@@ -202 +205 @@
  * Perturbation Walk with random element *
  *****************************************/
-proc prwalk(ideal Go, int radius, int o_pert_deg, int t_pert_deg, list #)
+proc prwalk(ideal Go, int radius, int o_pert_deg, int t_pert_deg, int reduction, int printout, list #)
 "SYNTAX: rwalk(ideal i, int radius);
          if size(#)>0 then rwalk(ideal i, int radius, intvec v, intvec w);
@@ -227 +230 @@
   OSCTW= OrderStringalp_NP("al", #);
   }
+int nP = OSCTW[1];
 string ord_str = OSCTW[2];
 intvec curr_weight = OSCTW[3]; // original weight vector
@@ -238 +242 @@
 
 ideal G = fetch(xR, Go);
-G = system("Mprwalk", G, curr_weight, target_weight, radius, o_pert_deg, t_pert_deg, basering);
+G = system("Mprwalk", G, curr_weight, target_weight, radius, o_pert_deg, t_pert_deg,
+           nP, reduction, printout);
 
 setring xR;
@@ -257 +262 @@
   int o_perturb_deg = 2;
   int t_perturb_deg = 2;
-  prwalk(I,radius,o_perturb_deg,t_perturb_deg);
+  int reduction = 0;
+  int printout = 2;
+  prwalk(I,radius,o_perturb_deg,t_perturb_deg,reduction,printout);
 }
 
@@ -263 +270 @@
  * Fractal Walk with random element *
  ************************************/
-proc frandwalk(ideal Go, int radius, list #)
-"SYNTAX: frwalk(ideal i, int radius);
-         frwalk(ideal i, int radius, intvec v, intvec w);
+proc frandwalk(ideal Go, int radius, int reduction, int printout, list #)
+"SYNTAX: frwalk(ideal i, int radius, int reduction, int printout);
+         frwalk(ideal i, int radius, int reduction, int printout, intvec v, intvec w);
 TYPE:    ideal
 PURPOSE: compute the standard basis of the ideal, calculated via
@@ -299 +306 @@
    ideal G = fetch(xR, Go);
    int pert_deg = 2;
-   G = system("Mfrwalk", G, curr_weight, target_weight, radius);
+
+   G = system("Mfrwalk", G, curr_weight, target_weight, radius, reduction, printout);
 
    setring xR;
@@ -314 +322 @@
     ring r = 0,(z,y,x), lp;
     ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
-    frandwalk(I,2);
-}
+    int reduction = 0;
+    frandwalk(I,2,0,1);
+}

Singular/LIB/schreyer.lib

@@ -49 +49 @@
 ";
 
-
 static proc prepareSyz( module I, list # )
 {
@@ -79 +78 @@
   }
 
-//  DetailedPrint(I);
+//   Syzextra::DetailedPrint(I);
 
   return(I);
@@ -93 +92 @@
   {
     v = J[i];
-    if( leadcomp(v) > c )
+    if(   Syzextra::leadcomp(v) > c )
     {
       II[i] = v;
@@ -118 +117 @@
     vv = 0;
     
-    while( leadcomp(v) <= c )
+    while(   Syzextra::leadcomp(v) <= c )
     {
       vv = vv + lead(v);
@@ -144 +143 @@
     "Sinit::Input";
     type(M);
-//    DetailedPrint(M);
+//      Syzextra::DetailedPrint(M);
     attrib(M);
   }
@@ -157 +156 @@
   }
 
-  def S = MakeInducedSchreyerOrdering(1); // 1 puts history terms to the back
+  def S =   Syzextra::MakeInducedSchreyerOrdering(1); // 1 puts history terms to the back
   // TODO: NOTE: +1 causes trouble to Singular interpreter!!!???
   setring S; // a new ring with a Schreyer ordering
@@ -165 +164 @@
     "Sinit::StartingISRing";
     basering; 
-//    DetailedPrint(basering);
+//      Syzextra::DetailedPrint(basering);
   }
 
@@ -190 +189 @@
     attrib(M);
     attrib(M, "isHomog");
-//    DetailedPrint(M);
+//      Syzextra::DetailedPrint(M);
   }
 
@@ -200 +199 @@
       transpose( transpose(M) * transpose(MRES) );
       "ERROR: transpose( transpose(M) * transpose(MRES) ) != 0!!!";
-      m2_end(666); 
+        Syzextra::m2_end(666); 
     }
   }
@@ -215 +214 @@
   {
     "Sinit::MRES";
-    DetailedPrint(MRES);
+      Syzextra::DetailedPrint(MRES);
     attrib(MRES, "isHomog");
     attrib(S);
@@ -232 +231 @@
   {
     "Sstep::NextInducedRing";
-    DetailedPrint(basering);
+      Syzextra::DetailedPrint(basering);
 
     attrib(basering, "InducionLeads");
     attrib(basering, "InducionStart");
 
-    GetInducedData();
+      Syzextra::GetInducedData();
   }
 
@@ -246 +245 @@
   def L =  lead(M);
   intvec @V = deg(M[1..ncols(M)]);  @W;  @V;  @W = @V;  attrib(L, "isHomog", @W);  
-  SetInducedReferrence(L, @RANK, 0);
+    Syzextra::SetInducedReferrence(L, @RANK, 0);
 */
 
@@ -255 +254 @@
 
   // General setting:
-//  SetInducedReferrence(MRES, 0, 0); // limit: 0!
+//    Syzextra::SetInducedReferrence(MRES, 0, 0); // limit: 0!
   int @l = size(RES);
 
@@ -287 +286 @@
     deg(M[1..ncols(M)]); // no use of @W :(?
     @RANK;   
-    DetailedPrint(MRES);
+      Syzextra::DetailedPrint(MRES);
     attrib(MRES, "isHomog"); @W;
     deg(MRES[1..ncols(MRES)]);
@@ -294 +293 @@
   
       
-  SetInducedReferrence(L, limit, 0);
+    Syzextra::SetInducedReferrence(L, limit, 0);
   
   def K = prepareSyz(M, @RANK);
 //  K;
   
-//   attrib(K, "isHomog", @V);   DetailedPrint(K, 1000);
+//   attrib(K, "isHomog", @V);     Syzextra::DetailedPrint(K, 1000);
 
 //  pause();
   
-  K = idPrepare(K, @RANK); // std(K); // ?
+  K =   Syzextra::idPrepare(K, @RANK); // std(K); // ?
   K = simplify(K, 2);
 
@@ -310 +309 @@
   module N = separateSyzGB(K, @RANK)[2]; // 1^st syz. module: vectors which start in lower part (comp >= @RANK)
 
-// "N_0: "; N; DetailedPrint(N, 10);
+// "N_0: "; N;   Syzextra::DetailedPrint(N, 10);
 
 //  basering; print(@V); type(N); 
@@ -328 +327 @@
         MRES;
 
-        "N: "; N; DetailedPrint(N, 10);
-
-        "K:"; K; DetailedPrint(K, 10);
+        "N: "; N;   Syzextra::DetailedPrint(N, 10);
+
+        "K:"; K;   Syzextra::DetailedPrint(K, 10);
 
         "RANKS: ", @RANK;
@@ -339 +338 @@
         "transpose(N) * transpose(MRES): ";
         transpose(N) * transpose(MRES);
-        DetailedPrint(module(_), 2);
-        m2_end(666); 
+          Syzextra::DetailedPrint(module(_), 2);
+          Syzextra::m2_end(666); 
       }
     }
@@ -357 +356 @@
   {
     "Sstep::NextSyzOutput: ";
-    DetailedPrint(N);
+      Syzextra::DetailedPrint(N);
     attrib(N, "isHomog");
   }
@@ -371 +370 @@
 "
 {
-  def data = GetInducedData();
+  def data =   Syzextra::GetInducedData();
            
   if( (!defined(RES)) || (!defined(MRES)) || (typeof(data) != "list") || (size(data) != 2) )
@@ -505 +504 @@
   if( size(M) > 0 )
   {
-    Sort_c_ds(@N);
+    Syzextra::Sort_c_ds(@N);
 
     if( @KERCHECK )
@@ -527 +526 @@
 
           "ERROR: MySort: wrong sorting in 'MySort': @N != @M!!!";
-          m2_end(666);
+            Syzextra::m2_end(666);
         }
       } 
@@ -549 +548 @@
     ERROR("Sorry: need an ideal or a module for input");
   }
-
-  // TODO! DONE?
   def @save = basering;
   
@@ -588 +585 @@
   }
 
-  
+  int @RINGCHANGE = 0;
+
+  if( typeof( attrib(SSinit, "RINGCHANGE") ) == "int" )
+  {
+    @RINGCHANGE = attrib(SSinit, "RINGCHANGE");
+  }
+
+
   if( @DEBUG )
   {
     "SSinit::Input";
     type(M);
-//    DetailedPrint(M);
     attrib(M);
   }
@@ -606 +609 @@
     option(set, opts);
     kill opts;
-  }//  else
-  // {
-    M = simplify(M, 1 + 2 + 4 + 32); // interreduce?
-  // }
+  }
+
+  M = simplify(M, 1 + 2 + 4 + 32);
 
   if( @IGNORETAILS )
@@ -621 +623 @@
     }
   }
-
-  
-
+  
   def @N = MySort(M); // TODO: replace with inplace sorting!!!
   def LEAD = lead(@N);
@@ -646 +646 @@
 
       "ERROR: wrong sorting (in SSnit): @N != M!!!";
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
 
@@ -658 +658 @@
 
       "ERROR: wrong sorting (in SSnit): @LEAD != LEAD!!!";
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
     
@@ -665 +665 @@
   M = @N;
   
-  def TAIL = Tail(M);
+  def TAIL =   Syzextra::Tail(M);
 
   int @RANK = nrows(M); int @SIZE = ncols(M);
@@ -672 +672 @@
   
   // TODO: what about real modules? weighted ones?
-  
-  list @l = ringlist(@save);
-
-  int @z = 0; ideal @m = maxideal(1); intvec @wdeg = deg(@m[1..ncols(@m)]);
-
-  // NOTE: @wdeg will be ignored anyway :(
-  @l[3] = list(list("C", @z), list("lp", @wdeg)); 
-
-  kill @z, @wdeg; // since these vars are ring independent!
-
-  def S = ring(@l); // --MakeInducedSchreyerOrdering(1);
-
-  module F = freemodule(@RANK);
-  intvec @V = deg(F[1..@RANK]);
-  
-  setring S; // ring with an easy divisibility test ("C, lex")
-
-  if( @DEBUG )
-  {
-    "SSinit::NewRing(C, lex)";
-    basering; 
-    DetailedPrint(basering);
-  }
+
+  if( @RINGCHANGE )
+  {
+    list @l = ringlist(@save);
+    int @z = 0; ideal @m = maxideal(1); intvec @wdeg = deg(@m[1..ncols(@m)]);
+    // NOTE: @wdeg will be ignored anyway :(
+    @l[3] = list(list("C", @z), list("lp", @wdeg)); 
+    kill @z, @m, @wdeg; // since these vars are ring independent!
+    def S = ring(@l); // --  Syzextra::MakeInducedSchreyerOrdering(1);
+    kill @l;
+    setring S; // ring with an easy divisibility test ("C, lex") // or not!???
+    if( @DEBUG )
+    {
+      "SSinit::NewRing(C,lex)?";
+      basering; 
+        Syzextra::DetailedPrint(basering);
+    }
+  } else 
+  { def S = basering; }
 
   // Setup the leading syzygy^{-1} module to zero:
   module Z = 0; Z[@RANK] = 0; attrib(Z, "isHomog", intvec(0));  
+
+  if( !@RINGCHANGE )
+  {
+    if( defined(RES) )  { if( @DEBUG ){ "WARN: killing existing object: RES!"; }; kill RES; }
+    if( defined(MRES) ) { if( @DEBUG ){ "WARN: killing existing object: MRES!"; }; kill MRES; }
+    if( defined(LRES) ) { if( @DEBUG ){ "WARN: killing existing object: LRES!"; }; kill LRES; }
+    if( defined(TRES) ) { if( @DEBUG ){ "WARN: killing existing object: TRES!"; }; kill TRES; }
+  }
 
   module MRES = Z;
@@ -704 +708 @@
   list LRES; LRES[1] = Z;
   list TRES; TRES[1] = Z;
-  
-  def M = imap(@save, M);
-
+ 
+  if( !defined(M) )
+  {
+    def M = imap(@save, M);
+  }
+
+  module F = freemodule(@RANK); intvec @V = deg(F[1..@RANK]); kill F;
+  
   attrib(M, "isHomog", @V);
   attrib(M, "isSB", 1);
   attrib(M, "degrees", @DEGS);  
   
-  def LEAD = imap(@save, LEAD);
+  if( !defined(LEAD) )
+  {
+    def LEAD = imap(@save, LEAD);
+  }  
   
   attrib(LEAD, "isHomog", @V);
   attrib(LEAD, "isSB", 1);  
   
-  def TAIL = imap(@save, TAIL);
+  if( !defined(TAIL) )
+  {
+    def TAIL = imap(@save, TAIL);
+  }  
 
   if( @DEBUG )
@@ -724 +739 @@
     attrib(M);
     attrib(M, "isHomog");
-//    DetailedPrint(M);
   }
 
@@ -734 +748 @@
       transpose( transpose(M) * transpose(MRES) );
       "ERROR: transpose( transpose(M) * transpose(MRES) ) != 0!!!";
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
   }
@@ -765 +779 @@
   }
 
-
   if( typeof( attrib(SSinit, "HYBRIDNF") ) == "int" )
   {
@@ -773 +786 @@
     attrib(S, "HYBRIDNF", 0);
   }
-  
+
+  // maybe resetting existing ring attributes!
   attrib(S, "DEBUG", @DEBUG);
   attrib(S, "SYZCHECK", @SYZCHECK);
@@ -785 +799 @@
     "SSinit::MRES";
     MRES;
-//    DetailedPrint(MRES);
+//      Syzextra::DetailedPrint(MRES);
     attrib(MRES, "isHomog");
     attrib(S);
@@ -860 +874 @@
   }
 
-  module SS = ComputeLeadingSyzygyTerms(L);
+  module SS =   Syzextra::ComputeLeadingSyzygyTerms(L);
 
   if( @KERCHECK )
@@ -878 +892 @@
     {
       a = L[i];
-      c = leadcomp(a);
+      c =   Syzextra::leadcomp(a);
       r = int(c);
 
-      aa = leadmonomial(a);
+      aa =   Syzextra::leadmonomial(a);
 
       M = 0;
@@ -889 +903 @@
         b = L[j];
 
-        if( leadcomp(b) == c )
+        if(   Syzextra::leadcomp(b) == c )
         {
-          bb = leadmonomial(b);
+          bb =   Syzextra::leadmonomial(b);
 
           M[j] = (lcm(aa, bb) / aa);
@@ -915 +929 @@
 
         "basering: "; basering;
-//        DetailedPrint(basering);
+//          Syzextra::DetailedPrint(basering);
 
         "S: ";  S;
-//        DetailedPrint(_, 1);
+//          Syzextra::DetailedPrint(_, 1);
         "SS: "; SS;
-//        DetailedPrint(_, 1);
+//          Syzextra::DetailedPrint(_, 1);
 
         "DIFF: ";
         module(matrix(S) - matrix(SS));
-//        DetailedPrint(_, 2);      
+//          Syzextra::DetailedPrint(_, 2);      
         print(matrix(S) - matrix(SS));
-        m2_end(666);
+          Syzextra::m2_end(666);
       }
     }
@@ -979 +993 @@
   }
 
-  module SS = Compute2LeadingSyzygyTerms(L);
+  module SS =   Syzextra::Compute2LeadingSyzygyTerms(L);
 
   if( @DEBUG )
@@ -994 +1008 @@
         transpose( transpose(SS) * transpose(L) );
         "ERROR: transpose( transpose(SS) * transpose(L) ) != 0!!!";
-        m2_end(666);
+          Syzextra::m2_end(666);
       }
     }
@@ -1023 +1037 @@
       a = L[i];
   //    "a: ", a;
-      c = leadcomp(a);
+      c =   Syzextra::leadcomp(a);
       r = int(c);
 
-      aa = leadmonomial(a);
+      aa =   Syzextra::leadmonomial(a);
 
       M = 0;
@@ -1035 +1049 @@
   //      "b: ", b;
 
-        if( leadcomp(b) == c )
+        if(   Syzextra::leadcomp(b) == c )
         {
-          bb = leadmonomial(b);
+          bb =   Syzextra::leadmonomial(b);
           @lcm = lcm(aa, bb);
 
@@ -1078 +1092 @@
           transpose( transpose(S) * transpose(L) );
           "ERROR: transpose( transpose(S) * transpose(L) ) != 0!!!";
-          m2_end(666);
+            Syzextra::m2_end(666);
         }
       }
@@ -1087 +1101 @@
       "ERROR: SSCompute2LeadingSyzygyTerms: size(S) != size(SS)";
 
-      "basering: "; basering; //      DetailedPrint(basering);
+      "basering: "; basering; //        Syzextra::DetailedPrint(basering);
 
       "S: ";  S;
-//      DetailedPrint(S, 2);
+//        Syzextra::DetailedPrint(S, 2);
       "SS: "; SS;
-//      DetailedPrint(SS, 2);
-      m2_end(666);
+//        Syzextra::DetailedPrint(SS, 2);
+        Syzextra::m2_end(666);
     }    
 
@@ -1103 +1117 @@
 
         "basering: ";  basering;
-//        DetailedPrint(basering);
+//          Syzextra::DetailedPrint(basering);
 
         "lead(S ): "; lead(S );
-//        DetailedPrint(_, 2);
+//          Syzextra::DetailedPrint(_, 2);
         "lead(SS): "; lead(SS);
-//        DetailedPrint(_, 2);
+//          Syzextra::DetailedPrint(_, 2);
 
         "DIFF: ";
         print( matrix(lead(S)) - matrix(lead(SS))  );
         module(matrix(lead(S)) - matrix(lead(SS)));
-//        DetailedPrint(_ , 4);
-        m2_end(666);
+//          Syzextra::DetailedPrint(_ , 4);
+          Syzextra::m2_end(666);
       }
 
@@ -1120 +1134 @@
       if( @TAILREDSYZ )
       {
-      if( size(module(matrix(Tail(S)) - matrix(Tail(SS)))) > 0 )
+      if( size(module(matrix(  Syzextra::Tail(S)) - matrix(  Syzextra::Tail(SS)))) > 0 )
       {
         "ERROR: SSCompute2LeadingSyzygyTerms: Tail(S) != Tail(SS) ";
 
         "basering: ";  basering;
-//        DetailedPrint(basering);
-
-        "Tail(S ): "; Tail(S );
-//        DetailedPrint(_, 2);
-        "Tail(SS): "; Tail(SS);
-//        DetailedPrint(_, 2);
+//          Syzextra::DetailedPrint(basering);
+
+        "Tail(S ): ";   Syzextra::Tail(S );
+//          Syzextra::DetailedPrint(_, 2);
+        "Tail(SS): ";   Syzextra::Tail(SS);
+//          Syzextra::DetailedPrint(_, 2);
 
         "DIFF: ";
-        module( matrix(Tail(S)) - matrix(Tail(SS)) );
-//        DetailedPrint(_, 4);
-        print( matrix(Tail(S)) - matrix(Tail(SS)) );
-        m2_end(666);
+        module( matrix(  Syzextra::Tail(S)) - matrix(  Syzextra::Tail(SS)) );
+//          Syzextra::DetailedPrint(_, 4);
+        print( matrix(  Syzextra::Tail(S)) - matrix(  Syzextra::Tail(SS)) );
+          Syzextra::m2_end(666);
       }
       }
@@ -1142 +1156 @@
   }
   
-  module S2 = Tail(SS);
+  module S2 =   Syzextra::Tail(SS);
   SS = lead(SS); // (C,lp) on base ring!
 
@@ -1153 +1167 @@
       type(S2);
       L;
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
   }  
@@ -1214 +1228 @@
   if( @DEBUG && (syzterm != 0) )
   {
-    def @@c = leadcomp(syzterm); int @@r = int(@@c);
-    def @@product = leadmonomial(syzterm) * L[@@r];
+    def @@c =   Syzextra::leadcomp(syzterm); int @@r = int(@@c);
+    def @@product =   Syzextra::leadmonomial(syzterm) * L[@@r];
 
     if( @@product != product)
@@ -1221 +1235 @@
       "product: ", product, ", @@product: ", @@product;
       "ERROR: 'syzterm' results in wrong product !!!???";
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
   }
@@ -1227 +1241 @@
   if( typeof(#[1]) == "module" )
   {
-    vector my = FindReducer(product, syzterm, L/*, T*/, #[1]);
+    vector my =   Syzextra::FindReducer(product, syzterm, L/*, T*/, #[1]);
   } else
   {
-    vector my = FindReducer(product, syzterm, L/*, T*/);
+    vector my =   Syzextra::FindReducer(product, syzterm, L/*, T*/);
   }
   
@@ -1236 +1250 @@
   if( @KERCHECK )
   {
-    bigint c = leadcomp(product); int r = int(c);
+    bigint c =   Syzextra::leadcomp(product); int r = int(c);
 
     def a, b, bb;
@@ -1247 +1261 @@
       a = L[k];
       // with the same mod. component
-      if( leadcomp(a) == c )
+      if(   Syzextra::leadcomp(a) == c )
       {
-        b = - (leadmonomial(product) / leadmonomial(L[k]));
+        b = - (  Syzextra::leadmonomial(product) /   Syzextra::leadmonomial(L[k]));
 
         // which divides the product: looking for the 1st appropriate one!
@@ -1287 +1301 @@
     if( my != nf )
     {
-      "ERROR in FindReducer => ", my, " != nf: ", nf;
-      m2_end(666);
+      "ERROR in   Syzextra::FindReducer => ", my, " != nf: ", nf;
+        Syzextra::m2_end(666);
     }
   }
@@ -1346 +1360 @@
   if( @SYZCHECK && (syzterm != 0) )
   {
-    def @@c = leadcomp(syzterm); int @@r = int(@@c);
-    poly @@m = leadmonomial(syzterm); def @@t = L[@@r];
+    def @@c =   Syzextra::leadcomp(syzterm); int @@r = int(@@c);
+    poly @@m =   Syzextra::leadmonomial(syzterm); def @@t = L[@@r];
 
     if( (@@m != m) || (@@t != t))
@@ -1354 +1368 @@
       "@@m: ", @@m, ", @@t: ", @@t;
       "ERROR: 'syzterm' results in wrong m * t !!!";
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
   }
@@ -1360 +1374 @@
   if( typeof(#[1]) == "module" )
   {
-    vector ss = ReduceTerm(m, t, syzterm, L, T, #[1]);
+    vector ss =   Syzextra::ReduceTerm(m, t, syzterm, L, T, #[1]);
   } else
   {
-    vector ss = ReduceTerm(m, t, syzterm, L, T);
+    vector ss =   Syzextra::ReduceTerm(m, t, syzterm, L, T);
   }
 
@@ -1380 +1394 @@
       if( size(s) != 0 )
       {
-        poly @b = leadmonomial(s);
-
-        def @c = leadcomp(s); int k = int(@c);
+        poly @b =   Syzextra::leadmonomial(s);
+
+        def @c =   Syzextra::leadcomp(s); int k = int(@c);
 
         if( @TREEOUTPUT ){ "\CHILD{", (s), "}{", ( @b*L[k]), "}"; }
@@ -1392 +1406 @@
     if( s != ss )
     {
-      "ERROR in ReduceTerm => old: ", s, " != ker: ", ss;
+      "ERROR in   Syzextra::ReduceTerm => old: ", s, " != ker: ", ss;
       "m: ", m;
       "t: ", t;
       "syzterm: ", syzterm;
        L; T; #;
-      m2_end(666);
+        Syzextra::m2_end(666);
     }  
   }
@@ -1445 +1459 @@
   if( typeof(#[1]) == "module" )
   {
-    vector ss = TraverseTail(m, @tail, L, T, #[1]);
+    vector ss =   Syzextra::TraverseTail(m, @tail, L, T, #[1]);
   } else
   {
-    vector ss = TraverseTail(m, @tail, L, T);
+    vector ss =   Syzextra::TraverseTail(m, @tail, L, T);
   }
 
@@ -1468 +1482 @@
     if( s != ss )
     {
-      "ERROR in TraverseTail => old: ", s, " != ker: ", ss;
+      "ERROR in   Syzextra::TraverseTail => old: ", s, " != ker: ", ss;
       "m: ", m;
       "@tail: ", @tail;
       L; T; #;
-      m2_end(666);
+        Syzextra::m2_end(666);
     }  
   }
@@ -1521 +1535 @@
   if( typeof(#[1]) == "module" )
   {
-    def my = SchreyerSyzygyNF(syz_lead, syz_2, L, T, #[1]);
+    def my =   Syzextra::SchreyerSyzygyNF(syz_lead, syz_2, L, T, #[1]);
   } else
   {
-    def my = SchreyerSyzygyNF(syz_lead, syz_2, L, T);
+    def my =   Syzextra::SchreyerSyzygyNF(syz_lead, syz_2, L, T);
   }
 
@@ -1531 +1545 @@
     int @TREEOUTPUT  = attrib(basering, "TREEOUTPUT");
     
-    def spoly = leadmonomial(syz_lead) * T[int(leadcomp(syz_lead))] 
-              + leadmonomial(syz_2)    * T[int(leadcomp(syz_2))];
+    def spoly =   Syzextra::leadmonomial(syz_lead) * T[int(  Syzextra::leadcomp(syz_lead))] 
+              +   Syzextra::leadmonomial(syz_2)    * T[int(  Syzextra::leadcomp(syz_2))];
 
     vector @tail = syz_2;
@@ -1540 +1554 @@
     while (size(spoly) > 0)
     {
-      syz_2 = SSFindReducer(lead(spoly), 0, L, #); spoly = Tail(spoly);
+      syz_2 = SSFindReducer(lead(spoly), 0, L, #); spoly =   Syzextra::Tail(spoly);
 
       if( size(syz_2) != 0)
       {          
-        @b = leadmonomial(syz_2);
-        k =  int(leadcomp(syz_2));
+        @b =   Syzextra::leadmonomial(syz_2);
+        k =  int(  Syzextra::leadcomp(syz_2));
         
         if( @TREEOUTPUT ){ "\CHILD{", (syz_2), "}{", ( lead(spoly)), "}"; }
@@ -1557 +1571 @@
     if( my != @tail )
     {
-      "ERROR in SchreyerSyzygyNF => old: ", @tail, " != ker: ", my;
+      "ERROR in   Syzextra::SchreyerSyzygyNF => old: ", @tail, " != ker: ", my;
       
       "syzygy_lead: ", syz_lead;
@@ -1563 +1577 @@
       
       L; T; #;
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
   }
@@ -1583 +1597 @@
 static proc SSComputeSyzygy(def L, def T)
 {
-//  rtimer, "***TIMESNAP0 for ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
+//  rtimer, "***TIMESNAP0 for   Syzextra::ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
   int @DEBUG    = attrib(basering, "DEBUG");
   int @KERCHECK = attrib(basering, "KERCHECK");
@@ -1592 +1606 @@
     "SSComputeSyzygy::Input";
     "basering: ", basering; attrib(basering);
-//    DetailedPrint(basering);
+//      Syzextra::DetailedPrint(basering);
 
 //    "iCompShift: ", iCompShift;
@@ -1601 +1615 @@
 
 //  option(prot); 
-//  rtimer, "***TIME for ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
-  list @res=ComputeSyzygy(L,T);
-//  rtimer, "***TIME for ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
+//  rtimer, "***TIME for   Syzextra::ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
+  list @res=  Syzextra::ComputeSyzygy(L,T);
+//  rtimer, "***TIME for   Syzextra::ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
 //  option(noprot); // TODO: restore!
 
@@ -1645 +1659 @@
       type(LL);
       type(@LL);
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
 
@@ -1656 +1670 @@
       type(LL);
       type(@LL);
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
 
@@ -1682 +1696 @@
         if( !@IGNORETAILS )
         {
-          c = leadcomp(a); r = int(c); aa = leadmonomial(a);
+          c =   Syzextra::leadcomp(a); r = int(c); aa =   Syzextra::leadmonomial(a);
           
           if( @TREEOUTPUT ){ "\ROOT{", (lead(a)), "}"; }
@@ -1694 +1708 @@
             if( @LEAD2SYZ ) // with the 2nd syz. term:
             {      
-              a2 = LL2[k]; c = leadcomp(a2); r = int(c); aa = leadmonomial(a2);
+              a2 = LL2[k]; c =   Syzextra::leadcomp(a2); r = int(c); aa =   Syzextra::leadmonomial(a2);
               
               if( @TREEOUTPUT ){ "\CHILD{", (lead(a2)), "}{", ( aa*L[r]), "}"; }
@@ -1721 +1735 @@
               {
                 "ERROR in SSComputeSyzygy: could not find the 2nd syzygy term during the hybrid NF!!!";
-                m2_end(666);
+                  Syzextra::m2_end(666);
               }
             }
@@ -1753 +1767 @@
 //              transpose( transpose(N) * transpose(MRES) );              
           
-          m2_end(666);
+            Syzextra::m2_end(666);
         }
 
@@ -1770 +1784 @@
       type(TT);
       type(@TT);
-      m2_end(666);
+        Syzextra::m2_end(666);
     }
 
@@ -1783 +1797 @@
       type(LL);
       type(@LL);
-      m2_end(666);
+        Syzextra::m2_end(666);
     }   
     
@@ -1804 +1818 @@
   }
 
-//  rtimer, "***TIMESNAP1 for ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
+//  rtimer, "***TIMESNAP1 for   Syzextra::ComputeSyzygy(L,T): on level: [",attrib(basering,"SYZNUMBER"),"] :: t: ", timer, ", r: ", rtimer;
   return (@SYZ, @LL, @TT);
 }
@@ -1826 +1840 @@
   def L =  lead(M);
   intvec @V = deg(M[1..ncols(M)]);  @W;  @V;  @W = @V;  attrib(L, "isHomog", @W);  
-  SetInducedReferrence(L, @RANK, 0);
+    Syzextra::SetInducedReferrence(L, @RANK, 0);
 */
 
@@ -1835 +1849 @@
 
   // General setting:
-//  SetInducedReferrence(MRES, 0, 0); // limit: 0!
+//    Syzextra::SetInducedReferrence(MRES, 0, 0); // limit: 0!
   int @l = size(RES);
 
@@ -1868 +1882 @@
     @V;
     @RANK;
-//    DetailedPrint(MRES);
+//      Syzextra::DetailedPrint(MRES);
     attrib(MRES, "isHomog");
   }
@@ -1892 +1906 @@
         "MRES", MRES;
 
-        "N: "; N; // DetailedPrint(N, 2);
-
-        "LL:"; LL; // DetailedPrint(LL, 1);
-        "TT:"; TT; // DetailedPrint(TT, 10);
+        "N: "; N; //   Syzextra::DetailedPrint(N, 2);
+
+        "LL:"; LL; //   Syzextra::DetailedPrint(LL, 1);
+        "TT:"; TT; //   Syzextra::DetailedPrint(TT, 10);
 
         "RANKS: ", @RANK;
@@ -1904 +1918 @@
         "transpose(N) * transpose(MRES): ";
         transpose(N) * transpose(MRES);
-        // DetailedPrint(module(_), 2);
-        m2_end(666);
+        //   Syzextra::DetailedPrint(module(_), 2);
+          Syzextra::m2_end(666);
       }
     }
@@ -1932 +1946 @@
     "SSstep::NextSyzOutput: ";
     N;
-//    DetailedPrint(N);
+//      Syzextra::DetailedPrint(N);
     attrib(N);
   }
@@ -1954 +1968 @@
 
   /// TODO!
-//  def data = GetInducedData();
+//  def data =   Syzextra::GetInducedData();
 
   if( (!defined(RES)) || (!defined(MRES)) ) /* || (typeof(data) != "list") || (size(data) != 2) */
@@ -2128 +2142 @@
 }
 
-// cannot be automatically used via overloading :(
-proc SRES_list(SRES SR)
-"TODO!"
-{
-  def save = basering;  
-  def R = SR.r;
-
-  if( 0 )  // ( save == R ) // TODO: not implemented :(((
-  {
-    list L = SR.rsltn;
-    return (L);
-  }
-    
-  setring R;
-  list L = SR.rsltn;
-  setring save;  
-  return (imap( R, L ));
-}
-
 static proc SRES_minres(SRES SR)
 {
@@ -2153 +2148 @@
   def R = SR.r; S.r = R;
   setring R;
-  S.rsltn = minres(SR.rsltn);
+  S.rsltn = minres(SR.rsltn); // in target ring :(
   return (S);
 }
 
-static proc loadme()
-{
-  int @DEBUG = 0; // !system("with", "ndebug");
-
-  if( @DEBUG )
-  {
+
+// cannot be automatically used via overloading :(
+proc SRES_list(def SR)
+"USAGE:  SRES_list(resolution)
+RETURN:  list
+PURPOSE: convert given resolution to a list
+NOTE:    result is over basering
+SEE ALSO: s_res, resolution
+EXAMPLE: example s_res; shows an example
+"
+{
+  if( typeof(SR) != "SRES" )
+  {
+    list @@@L = SR;
+    return (@@@L);
+  }
+  
+  def save = basering;  
+  def R = SR.r;
+
+//    if( 0 )  // ( save == R ) // TODO: not implemented :(((
+//    {      list L = SR.rsltn;      return (L);    }
     
-//    "ndebug?: ", system("with", "ndebug");
-//    "om_ndebug?: ", system("with", "om_ndebug");
-
-    listvar(Syzextra);
-    listvar(Schreyer);
-    listvar(Top);
-  }
-
-  if( !defined(Schreyer::DetailedPrint) )
-  {
-    if( 1 )
-    {
-/*
-      if( system("with", "ndebug") )
-      {
-        "Loading the Debug version!";
-      } else
-      {
-        "Loading the Release version!";
-      }
-*/      
+  setring R;
+  
+  list @@@L = SR.rsltn;
+  setring save;  
+  return (imap( R, @@@L ));
+}
+
+static proc mod_init()
+{
+  int @DEBUG = 0; // !system("with", "ndebug"); //    "om_ndebug?: ", system("with", "om_ndebug");
+
+  if( @DEBUG )  {    listvar(Top);  }
+
+  if( !defined(SRES) )
+  {
       load("syzextra.so");
 
-      if( @DEBUG )
-      {
-        listvar(Syzextra);
-      }
+      if( @DEBUG ){        listvar(Syzextra);      }
       
-//      exportto(Top, Syzextra::ClearContent);
-//      exportto(Top, Syzextra::ClearDenominators);
-      exportto(Schreyer, Syzextra::m2_end);
-      
-//      export Syzextra;
-
-//      exportto(Schreyer, Syzextra::noop);
-      exportto(Schreyer, Syzextra::DetailedPrint);
-      exportto(Schreyer, Syzextra::leadmonomial);
-      exportto(Schreyer, Syzextra::leadcomp);
-//      exportto(Schreyer, Syzextra::leadrawexp);
-//      exportto(Schreyer, Syzextra::ISUpdateComponents);
-      exportto(Schreyer, Syzextra::SetInducedReferrence);
-      exportto(Schreyer, Syzextra::GetInducedData);
-//      exportto(Schreyer, Syzextra::GetAMData);
-//      exportto(Schreyer, Syzextra::SetSyzComp);
-      exportto(Schreyer, Syzextra::MakeInducedSchreyerOrdering);
-//      exportto(Schreyer, Syzextra::MakeSyzCompOrdering);
-      exportto(Schreyer, Syzextra::idPrepare);
-//      exportto(Schreyer, Syzextra::reduce_syz);
-//      exportto(Schreyer, Syzextra::p_Content);
-
-      exportto(Schreyer, Syzextra::ProfilerStart); exportto(Schreyer, Syzextra::ProfilerStop);
-
-      exportto(Schreyer, Syzextra::Tail);
-      exportto(Schreyer, Syzextra::ComputeLeadingSyzygyTerms);      
-      exportto(Schreyer, Syzextra::Compute2LeadingSyzygyTerms);
-      exportto(Schreyer, Syzextra::Sort_c_ds);
-
-      exportto(Schreyer, Syzextra::FindReducer);
-
-      exportto(Schreyer, Syzextra::ReduceTerm);
-      exportto(Schreyer, Syzextra::TraverseTail);
-
-      exportto(Schreyer, Syzextra::SchreyerSyzygyNF);
-      exportto(Schreyer, Syzextra::ComputeSyzygy);
-
-      exportto(Schreyer, Syzextra::ComputeResolution);
-
-      exportto(Schreyer, Syzextra::NumberStatsInit);
-      exportto(Schreyer, Syzextra::NumberStatsPrint);
-
-      newstruct("SRES","ring r,resolution rsltn"); // http://www.singular.uni-kl.de/Manual/latest/sing_179.htm#SEC218
-      // TODO: SSres - return SRESOLUTION?
-
+//      exportto(Top,   Syzextra::ClearContent); //      exportto(Top,   Syzextra::ClearDenominators);     exportto(Schreyer,   Syzextra::noop);
+//      exportto(Schreyer,   Syzextra::leadrawexp); //      exportto(Schreyer,   Syzextra::ISUpdateComponents);
+//      exportto(Schreyer,   Syzextra::GetAMData);//      exportto(Schreyer,   Syzextra::SetSyzComp);
+//      exportto(Schreyer,   Syzextra::MakeSyzCompOrdering); //      exportto(Schreyer,   Syzextra::reduce_syz);//      exportto(Schreyer,   Syzextra::p_Content);
+
+//    exportto(Schreyer,   Syzextra::DetailedPrint);
+//    exportto(Schreyer,   Syzextra::m2_end);
+//    exportto(Schreyer,   Syzextra::leadmonomial);
+//    exportto(Schreyer,   Syzextra::leadcomp);
+//    exportto(Schreyer,   Syzextra::SetInducedReferrence);
+//    exportto(Schreyer,   Syzextra::GetInducedData);
+//    exportto(Schreyer,   Syzextra::MakeInducedSchreyerOrdering);
+//    exportto(Schreyer,   Syzextra::idPrepare);    
+//    exportto(Schreyer,   Syzextra::ProfilerStart);   exportto(Schreyer,   Syzextra::ProfilerStop);
+//    exportto(Schreyer,   Syzextra::NumberStatsInit); exportto(Schreyer,   Syzextra::NumberStatsPrint);    
+//    exportto(Schreyer,   Syzextra::Tail);
+//    exportto(Schreyer,   Syzextra::ComputeLeadingSyzygyTerms);
+//    exportto(Schreyer,   Syzextra::Compute2LeadingSyzygyTerms);
+//    exportto(Schreyer,   Syzextra::Sort_c_ds);    
+//    exportto(Schreyer,   Syzextra::FindReducer);
+//    exportto(Schreyer,   Syzextra::ReduceTerm);
+//    exportto(Schreyer,   Syzextra::TraverseTail);    
+//    exportto(Schreyer,   Syzextra::SchreyerSyzygyNF);
+//    exportto(Schreyer,   Syzextra::ComputeSyzygy);
+//    exportto(Schreyer,   Syzextra::ComputeResolution);
+    
+    // TODO: SSres - return SRESOLUTION?
+    newstruct("SRES","ring r,resolution rsltn"); // http://www.singular.uni-kl.de/Manual/latest/sing_179.htm#SEC218
 //      system("install","SRES","string",SRES_string, 1);
-      system("install","SRES","print",SRES_print, 1);
-
-      system("install","SRES","betti",SRES_betti1, 1); // http://www.singular.uni-kl.de/Manual/latest/sing_260.htm#SEC299
-      system("install","SRES","betti",SRES_betti2, 2); // http://www.singular.uni-kl.de/Manual/latest/sing_260.htm#SEC299
-      system("install","SRES","minres",SRES_minres, 1); // http://www.singular.uni-kl.de/Manual/latest/sing_344.htm#SEC383
-
-//      system("install","SRES","list", SRES_list, 1); // will never work :(((
-      
-      // TODO: SSsyz? SSYZYGY? // TODO: C/C++ computation for Syzygy?
-//      newstruct("SSYZ","ring r,module szg"); // http://www.singular.uni-kl.de/Manual/latest/sing_179.htm#SEC218
-//      system("install","SSYZYGY","string",SSYZYGY_string, 1);
-//      system("install","SSYZYGY","print",SSYZYGY_print, 1);
-//      system("install","SSYZYGY","module",SSYZYGY_module, 1);
-    }
-
-//    exportto(Top, DetailedPrint);
-//    exportto(Top, GetInducedData);
-
-    if( @DEBUG )
-    {
-      listvar(Top);
-      listvar(Schreyer);
-    }
-  }
-  
-  mod_assure_load();
-}
-
-
-
-static proc mod_assure_load()
-{
-  if( !defined(GetInducedData) )
-  {
-    "ERROR: Sorry but we are missing the dynamic module (syzextra.so)...";
-    $
-    // m2_end(666); // :(
-  }
-}
-
-static proc mod_init()
-{
-  loadme();
+    system("install","SRES","print",SRES_print, 1);
+    system("install","SRES","betti",SRES_betti1, 1); // http://www.singular.uni-kl.de/Manual/latest/sing_260.htm#SEC299
+    system("install","SRES","betti",SRES_betti2, 2); // http://www.singular.uni-kl.de/Manual/latest/sing_260.htm#SEC299
+    system("install","SRES","minres",SRES_minres, 1); // http://www.singular.uni-kl.de/Manual/latest/sing_344.htm#SEC383
+    system("install","SRES","list", SRES_list, 1); // will never work :(((
+
+//    exportto(Top, s_res); //   Syzextra::GetInducedData);
+
+    if( @DEBUG )    {      listvar(Top);      listvar(Schreyer);    }
+  }
 }
 
@@ -2395 +2347 @@
     
     "ERROR: There were some wrong betti numbers... ";
-//    m2_end(666);    
+//      Syzextra::m2_end(666);    
   } else
   {
@@ -2494 +2446 @@
   {
     "ERROR: non-square M!!!";
-    m2_end(666);
+      Syzextra::m2_end(666);
   }
 
@@ -2504 +2456 @@
     "MRES': "; M; print(M);
 
-    m2_end(666);
+      Syzextra::m2_end(666);
   }
 //  "MRES': "; M; print(M);
@@ -2511 +2463 @@
   {
     "ERROR: wrong starting zero module!!!";
-    m2_end(666);
+      Syzextra::m2_end(666);
   }
 
@@ -2544 +2496 @@
   
   option(redSB); option(redTail);
-  if(@PROFILE){ProfilerStart(@prof);}
+  if(@PROFILE){  Syzextra::ProfilerStart(@prof);}
   timer=0;rtimer=0;def R=SSres(I,0);@m=rtimer;
-  if(@PROFILE){ProfilerStop();}
+  if(@PROFILE){  Syzextra::ProfilerStop();}
   setring R;module M;list @l=list();@l[size(RES)-1]=list();r=nrows(RES[1]);for(i=2;i<=size(RES);i++){M=RES[i];rr=nrows(M);if((r>0)&&(size(M)>0)&&(r<rr)){M=transpose(M);M=M[(r+1)..ncols(M)];M=transpose(M);RES[i]=M;};r=rr;@l[i-1] = M;};resolution RR=@l;RR=minres(RR);def S=betti(RR,1);@t=rtimer;
-//  DetailedPrint(RR,0);
+//    Syzextra::DetailedPrint(RR,0);
   SCheck(R);
   StopAddResTest(RR, S, @t,@m); 
@@ -2556 +2508 @@
 proc s_res(def I, int l)
 "USAGE:  s_res(ideal/module M, int len)
-RETURN:  SRES, a blackbox object containing a (part of) Schreyer resolution
+RETURN:  resolution object or SRES
 PURPOSE: compute a Schreyer resolution of M of length at most len (see [BMSS])
 NOTE:    If given len is zero then nvars(basering) + 1 is used instead.
-@* SRES can be printed, treated by betti and minres or converted to list & mapped into the current ring with @code{SRES_list}
 @* This functions is not related to other helpers from this library.
 @* One can switch on computation protocol and statistic (depending on the build) by setting the @code{prot} option.
@@ -2569 +2520 @@
 "
 {
-  int @prot = (find(option(),"prot") != 0) && (defined(NumberStatsInit)) && (defined(NumberStatsPrint));
-  def R=SSinit(I); setring R; int @l = size(RES);
-  SRES ret; ret.r = R; 
-  if(@prot){ NumberStatsInit(); }
-  ret.rsltn = ComputeResolution(RES[@l], LRES[@l], TRES[@l], l);
-  if(@prot){ NumberStatsPrint("Number statistic for s_res with ComputeResolution"); }
+  int @prot = (find(option(),"prot") != 0) && (defined(  Syzextra::NumberStatsInit)) && (defined(  Syzextra::NumberStatsPrint));
+  def @save = basering;
+  
+  int @RINGCHANGE = 0;
+
+  if( typeof( attrib(SSinit, "RINGCHANGE") ) == "int" )
+  {
+    @RINGCHANGE = attrib(SSinit, "RINGCHANGE");
+  }
+  
+  def R=SSinit(I);
+  if( @RINGCHANGE ){ setring R; }
+  
+  int @l = size(RES);
+  if(@prot){   Syzextra::NumberStatsInit(); }
+  def rsltn =   Syzextra::ComputeResolution(RES[@l], LRES[@l], TRES[@l], l);
+  if(@prot){   Syzextra::NumberStatsPrint("Number statistic for s_res with   Syzextra::ComputeResolution"); }
+  
+  if( !@RINGCHANGE )
+  {
+    return (rsltn); // ret
+  }
+  
+  SRES ret; ret.r = R; ret.rsltn = rsltn;  
   return (ret);
 }
@@ -2581 +2550 @@
   ring R;
   module M = maxideal(1); M;
-  SRES rs = s_res(M, 0); 
+  def  rs = s_res(M, 0); 
   print(rs);
   print(betti(rs, 0)); // non-minimal betties
@@ -2589 +2558 @@
 }
 
+static proc s_res_bm(def I)
+{
+  int @prot = (find(option(),"prot") != 0) && (defined(  Syzextra::NumberStatsInit)) && (defined(  Syzextra::NumberStatsPrint));
+  def @save = basering;
+  
+  int @RINGCHANGE = 0;
+
+  if( typeof( attrib(SSinit, "RINGCHANGE") ) == "int" )
+  {
+    @RINGCHANGE = attrib(SSinit, "RINGCHANGE");
+  }
+  int t,tt,sum;
+  
+t=rtimer;def R=SSinit(I);tt=rtimer;
+
+  "%% Setup(SSinit) TIME:", tt - t; // if(@prot){ } ?
+  int sum = (tt-t);
+
+  if( @RINGCHANGE ){ setring R; }
+  
+  int @l = size(RES);
+  module N, L, T, LL, TT;
+  L = LRES[@l];
+  T = TRES[@l];
+
+  
+  int ss = attrib(basering, "SYZNUMBER");
+  
+  while ( 1 )
+  {
+    if(@prot){   Syzextra::NumberStatsInit(); }
+
+//  SSstep():
+t=rtimer;(N,LL,TT)=SSComputeSyzygy(L,T);tt=rtimer;
+    
+    @l = @l + 1; 
+    if(@prot){   Syzextra::NumberStatsPrint("Number statistic for SSComputeSyzygy["+string(@l-2)+"]"); }
+    "%% SSstep[",@l-2, "] TIME:", tt - t;  // if(@prot){ } ?
+    sum = sum + (tt-t);
+    
+    if( (size(LL) == 0) || (size(N) == 0) ) { break; }
+    L = LL; T = TT; RES[@l] = N; // LRES[@l] = LL; TRES[@l] = TT;
+
+    ss = ss + 1; attrib(basering, "SYZNUMBER", ss );    
+  }
+  
+  "%% Whole Resolution (with "+string(@l)+"syzygies) TIME:", sum;  // if(@prot){ } ?
+  resolution rsltn = list(RES[2..size(RES)]);
+  
+  if( !@RINGCHANGE )
+  {
+    return (rsltn); // ret
+  }
+  
+  SRES ret; ret.r = R; ret.rsltn = rsltn;
+  return (ret);
+}
+
+
 static proc s_syz(def I)
 {
@@ -2594 +2622 @@
   int @l = size(RES); //   def M =  RES[@l];
   module N, LL, TT; (N, LL, TT) = SSComputeSyzygy(LRES[@l], TRES[@l]);
-  SSYZ ret; ret.r = R; ret.szg = N; // Schreyer::ComputeResolution(RES[2], LRES[2], TRES[2], 0);
+  SSYZ ret; ret.r = R; ret.szg = N; // Schreyer::  Syzextra::ComputeResolution(RES[2], LRES[2], TRES[2], 0);
   return (ret);
 }
@@ -2616 +2644 @@
   
   option(redSB); option(redTail);
-  if(@PROFILE){ProfilerStart(@prof);}
-  timer=0;rtimer=0;def R=SSinit(I);setring R;def RR=ComputeResolution(RES[2], LRES[2], TRES[2], 0);
+  if(@PROFILE){  Syzextra::ProfilerStart(@prof);}
+  timer=0;rtimer=0;def R=SSinit(I);setring R;def RR=  Syzextra::ComputeResolution(RES[2], LRES[2], TRES[2], 0);
 @m=rtimer;
-  if(@PROFILE){ProfilerStop();}
-RR=minres(RR);def S=betti(RR,1);@t=rtimer;
-//  DetailedPrint(RR,0);  print(RR);  print(S, "betti");
+  if(@PROFILE){  Syzextra::ProfilerStop();}
+RR=minres(RR); def S=betti(RR,1);@t=rtimer;
+//    Syzextra::DetailedPrint(RR,0);  print(RR);  print(S, "betti");
   SCheck(R);
   StopAddResTest(RR, S, @t,@m); 
@@ -2717 +2745 @@
 static proc testSimple(list #)
 {
-  mod_assure_load();
-
   def DEBUG = 0;
   if(size(#) > 0) { DEBUG = #[1]; }

Singular/LIB/standard.lib

@@ -1389 +1389 @@
      return(nres(m,i));
    }
+   
+/* if( attrib(basering, "global") == 1 ) // preparations for s_res usage. in testing!
+   {
+     if (p_opt) { "using s_res";}
+     if( !defined(s_res) )
+     {
+       def @@v=option(get); option(noloadLib); option(noloadProc); LIB( "schreyer.lib" ); // for s_res
+       option(set, @@v); kill @@v;
+     }  
+     resolution re = s_res(m,i);
+     if(size(#)>2)
+     {
+       re=minres(re);
+     }
+     return(re);   
+   }*/
 
    if(homog(m)==1)

Singular/Makefile.am

@@ -1 @@
-ACLOCAL_AMFLAGS = -I ../m4
+ACLOCAL_AMFLAGS = -I../m4
 
 GIT_VERSION := $(shell $(top_srcdir)/git-version-gen $(top_srcdir)/.tarball-git-version)
@@ -156 +156 @@
 bin_PROGRAMS = Singular ESingular TSingular $(optional_Singular_programs)
 
+# the following dependency leads to Singular relinking upon a library update!
 Singular ESingular TSingular $(optional_Singular_programs): ${abs_builddir}/LIB
 

Singular/extra.cc

@@ -709 +709 @@
         return TRUE;
       }
+      if (rField_is_Ring(currRing))
+      {
+        WerrorS("field required");
+        return TRUE;
+      }
       matrix pMat  = (matrix)h->Data();
       matrix lMat  = (matrix)h->next->Data();
@@ -943 +948 @@
       if (h!=NULL)
       {
-        res->rtyp=h->Typ();
-        if (h->Typ()==BIGINTMAT_CMD)
-        {
-          res->data=(char *)singflint_LLL((bigintmat*)h->Data());
-          return FALSE;
-        }
-        else if (h->Typ()==INTMAT_CMD)
-        {
-          res->data=(char *)singflint_LLL((intvec*)h->Data());
-          return FALSE;
-        }
-        else return TRUE;
+        if(h->next == NULL)
+        {
+            res->rtyp=h->Typ();
+            if (h->Typ()==BIGINTMAT_CMD)
+            {
+              res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
+              return FALSE;
+            }
+            else if (h->Typ()==INTMAT_CMD)
+            {
+              res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
+              return FALSE;
+            }
+            else return TRUE;
+        }
+        if(h->next->Typ()!= INT_CMD)
+        {
+            WerrorS("matrix,int or bigint,int expected");
+            return TRUE;
+        }
+        if(h->next->Typ()== INT_CMD)
+        {
+            if(((int)((long)(h->next->Data())) != 0) && (int)((long)(h->next->Data()) != 1))
+            {
+                WerrorS("int is different from 0, 1");
+                return TRUE;
+            }
+            res->rtyp=h->Typ();
+            if((long)(h->next->Data()) == 0)
+            {
+                if (h->Typ()==BIGINTMAT_CMD)
+                {
+                  res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
+                  return FALSE;
+                }
+                else if (h->Typ()==INTMAT_CMD)
+                {
+                  res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
+                  return FALSE;
+                }
+                else return TRUE;
+            }
+            // This will give also the transformation matrix U s.t. res = U * m
+            if((long)(h->next->Data()) == 1)
+            {
+                if (h->Typ()==BIGINTMAT_CMD)
+                {
+                  bigintmat* m = (bigintmat*)h->Data();
+                  bigintmat* T = new bigintmat(m->rows(),m->rows(),m->basecoeffs());
+                  for(int i = 1; i<=m->rows(); i++)
+                  {
+                    n_Delete(&(BIMATELEM(*T,i,i)),T->basecoeffs());
+                    BIMATELEM(*T,i,i)=n_Init(1, T->basecoeffs());
+                  }
+                  m = singflint_LLL(m,T);
+                  lists L = (lists)omAllocBin(slists_bin);
+                  L->Init(2);
+                  L->m[0].rtyp = BIGINTMAT_CMD;  L->m[0].data = (void*)m;
+                  L->m[1].rtyp = BIGINTMAT_CMD;  L->m[1].data = (void*)T;
+                  res->data=L;
+                  res->rtyp=LIST_CMD;
+                  return FALSE;
+                }
+                else if (h->Typ()==INTMAT_CMD)
+                {
+                  intvec* m = (intvec*)h->Data();
+                  intvec* T = new intvec(m->rows(),m->rows(),(int)0);
+                  for(int i = 1; i<=m->rows(); i++)
+                    IMATELEM(*T,i,i)=1;
+                  m = singflint_LLL(m,T);
+                  lists L = (lists)omAllocBin(slists_bin);
+                  L->Init(2);
+                  L->m[0].rtyp = INTMAT_CMD;  L->m[0].data = (void*)m;
+                  L->m[1].rtyp = INTMAT_CMD;  L->m[1].data = (void*)T;
+                  res->data=L;
+                  res->rtyp=LIST_CMD;
+                  return FALSE;
+                }
+                else return TRUE;
+            }
+        }
+        
       }
       else return TRUE;

Singular/ipshell.cc

@@ -2073 +2073 @@
   // 0: string: integer
   // no further entries --> Z
-  int_number modBase = NULL;
+  mpz_ptr modBase = NULL;
   unsigned int modExponent = 1;
 
-  modBase = (int_number) omAlloc(sizeof(mpz_t));
+  modBase = (mpz_ptr) omAlloc(sizeof(mpz_t));
   if (L->nr == 0)
   {
@@ -2130 +2130 @@
   {
     //R->cf->ch = R->cf->modExponent;
-    if ((mpz_cmp_ui(modBase, 2) == 0) && (modExponent <= 8*sizeof(NATNUMBER)))
+    if ((mpz_cmp_ui(modBase, 2) == 0) && (modExponent <= 8*sizeof(unsigned long)))
     {
       /* this branch should be active for modExponent = 2..32 resp. 2..64,
@@ -5123 +5123 @@
 #ifdef HAVE_RINGS
   //unsigned int ringtype = 0;
-  int_number modBase = NULL;
+  mpz_ptr modBase = NULL;
   unsigned int modExponent = 1;
 #endif
@@ -5266 +5266 @@
   else if ((pn->name != NULL) && (strcmp(pn->name, "integer") == 0))
   {
-    modBase = (int_number) omAlloc(sizeof(mpz_t));
+    modBase = (mpz_ptr) omAlloc(sizeof(mpz_t));
     mpz_init_set_si(modBase, 0);
     if (pn->next!=NULL)
@@ -5309 +5309 @@
     if (modExponent > 1 && cf == NULL)
     {
-      if ((mpz_cmp_ui(modBase, 2) == 0) && (modExponent <= 8*sizeof(NATNUMBER)))
+      if ((mpz_cmp_ui(modBase, 2) == 0) && (modExponent <= 8*sizeof(unsigned long)))
       {
         /* this branch should be active for modExponent = 2..32 resp. 2..64,

Singular/number2.cc

@@ -44 +44 @@
     {
       ZnmInfo info;
-      mpz_ptr modBase= (int_number) omAlloc(sizeof(mpz_t));
+      mpz_ptr modBase= (mpz_ptr) omAlloc(sizeof(mpz_t));
       mpz_init_set_ui(modBase,i2);
       info.base= modBase;

Singular/walk.cc

@@ -431 +431 @@
 #endif
 
-#ifdef CHECK_IDEAL_MWALK
+//#ifdef CHECK_IDEAL_MWALK
 static void idString(ideal L, const char* st)
 {
@@ -443 +443 @@
   Print(" %s;", pString(L->m[nL-1]));
 }
-#endif
+//#endif
 
 #if defined(CHECK_IDEAL_MWALK) || defined(ENDWALKS)
@@ -560 +560 @@
   }
   return p0;
+}
+
+/*****************************************************************************
+ * compute the gcd of the entries of the vectors curr_weight and diff_weight *
+ *****************************************************************************/
+static int simplify_gcd(intvec* curr_weight, intvec* diff_weight)
+{
+  int j;
+  int nRing = currRing->N;
+  int gcd_tmp = (*curr_weight)[0];
+  for (j=1; j<nRing; j++)
+  {
+    gcd_tmp = gcd(gcd_tmp, (*curr_weight)[j]);
+    if(gcd_tmp == 1)
+    {
+      break;
+    }
+  }
+  if(gcd_tmp != 1)
+  {
+    for (j=0; j<nRing; j++)
+    {
+    gcd_tmp = gcd(gcd_tmp, (*diff_weight)[j]);
+    if(gcd_tmp == 1)
+      {
+        break;
+      }
+    }
+  }
+  return gcd_tmp;
 }
 
@@ -955 +985 @@
 }
 
-/*****************************************************************************
-* create a weight matrix order as intvec of an extra weight vector (a(iv),lp)*
-******************************************************************************/
+/*********************************************************************************
+* create a weight matrix order as intvec of an extra weight vector (a(iv),M(iw)) *
+**********************************************************************************/
 intvec* MivMatrixOrderRefine(intvec* iv, intvec* iw)
 {
-  assume(iv->length() == iw->length());
-  int i, nR = iv->length();
+  assume((iv->length())*(iv->length()) == iw->length());
+  int i,j, nR = iv->length();
   
   intvec* ivm = new intvec(nR*nR);
@@ -968 +998 @@
   {
     (*ivm)[i] = (*iv)[i];
-    (*ivm)[i+nR] = (*iw)[i];
-  }
-  for(i=2; i<nR; i++)
-  {
-    (*ivm)[i*nR+i-2] = 1;
+  }
+  for(i=1; i<nR; i++)
+  {
+    for(j=0; j<nR; j++)
+    {
+      (*ivm)[j+i*nR] = (*iw)[j+i*nR];
+    }
   }
   return ivm;
@@ -1861 +1893 @@
 }
 
+
+/**************************************************************
+ * Look for the position of the smallest absolut value in vec *
+ **************************************************************/
+static int MivAbsMaxArg(intvec* vec)
+{
+  int k = MivAbsMax(vec);
+  int i=0;
+  while(1)
+  {
+    if((*vec)[i] == k || (*vec)[i] == -k)
+    {
+      break;
+    }
+    i++;
+  }
+  return i;
+}
+
+
 /**********************************************************************
  * Compute a next weight vector between curr_weight and target_weight *
@@ -1875 +1927 @@
 
   int nRing = currRing->N;
-  int checkRed, j, kkk, nG = IDELEMS(G);
+  int checkRed, j, nG = IDELEMS(G);
   intvec* ivtemp;
 
@@ -1913 +1965 @@
   mpz_init(dcw);
 
-  //int tn0, tn1, tz1, ncmp, gcd_tmp, ntmp;
   int gcd_tmp;
   intvec* diff_weight = MivSub(target_weight, curr_weight);
@@ -1919 +1970 @@
   intvec* diff_weight1 = MivSub(target_weight, curr_weight);
   poly g;
-  //poly g, gw;
+
   for (j=0; j<nG; j++)
   {
@@ -1981 +2032 @@
     }
   }
-//Print("\n// Alloc Size = %d \n", nRing*sizeof(mpz_t));
+  //Print("\n// Alloc Size = %d \n", nRing*sizeof(mpz_t));
   mpz_t *vec=(mpz_t*)omAlloc(nRing*sizeof(mpz_t));
 
 
-  // there is no 0<t<1 and define the next weight vector that is equal to the current weight vector
+  // there is no 0<t<1 and define the next weight vector that is equal
+  // to the current weight vector
   if(mpz_cmp(t_nenner, t_null) == 0)
   {
@@ -2056 +2108 @@
 #endif
 
-  //  BOOLEAN isdwpos;
-
-  // construct a new weight vector
+// construct a new weight vector and check whether vec[j] is overflow,
+// i.e. vec[j] > 2^31.
+// If vec[j] doesn't overflow, define a weight vector. Otherwise,
+// report that overflow appears. In the second case, test whether the
+// the correctness of the new vector plays an important role
+
   for (j=0; j<nRing; j++)
   {
@@ -2102 +2157 @@
     }
   }
-
+  // reduce the vector with the gcd
+  if(mpz_cmp_si(ggt,1) != 0)
+  {
+    for (j=0; j<nRing; j++)
+    {
+      mpz_divexact(vec[j], vec[j], ggt);
+    }
+  }
 #ifdef  NEXT_VECTORS_CC
   PrintS("\n// gcd of elements of the vector: ");
@@ -2108 +2170 @@
 #endif
 
-/**********************************************************************
-* construct a new weight vector and check whether vec[j] is overflow, *
-* i.e. vec[j] > 2^31.                                                 *
-* If vec[j] doesn't overflow, define a weight vector. Otherwise,      *
-* report that overflow appears. In the second case, test whether the  *
-* the correctness of the new vector plays an important role           *
-**********************************************************************/
-  kkk=0;
   for(j=0; j<nRing; j++)
     {
@@ -2131 +2185 @@
 
   REDUCTION:
+  checkRed = 1;
   for (j=0; j<nRing; j++)
   {
-    (*diff_weight)[j] = mpz_get_si(vec[j]);
-  }
-  while(MivAbsMax(diff_weight) >= 5)
-  {
-    for (j=0; j<nRing; j++)
-    {
-      if(mpz_cmp_si(ggt,1)==0)
-      {
-        (*diff_weight1)[j] = floor(0.1*(*diff_weight)[j] + 0.5);
-        // Print("\n//  vector[%d] = %d \n",j+1, (*diff_weight1)[j]);
-      }
-      else
-      {
-        mpz_divexact(vec[j], vec[j], ggt);
-        (*diff_weight1)[j] = floor(0.1*(*diff_weight)[j] + 0.5);
-        // Print("\n//  vector[%d] = %d \n",j+1, (*diff_weight1)[j]);
-      }
-/*
-      if((*diff_weight1)[j] == 0)
-      {
-        kkk = kkk + 1;
-      }
-*/
-    }
-
-
-/*
-    if(kkk > nRing - 1)
-    {
-      // diff_weight was reduced to zero
-      // Print("\n // MwalkNextWeightCC: geaenderter Vector gleich Null! \n");
-      goto TEST_OVERFLOW;
-    }
-*/
-
-    if(test_w_in_ConeCC(G,diff_weight1) != 0)
-    {
-      Print("\n// MwalkNextWeightCC: geaenderter vector liegt in Groebnerkegel! \n");
-      for (j=0; j<nRing; j++)
-      {
-        (*diff_weight)[j] = (*diff_weight1)[j];
-      }
-      if(MivAbsMax(diff_weight) < 5)
-      {
-        checkRed = 1;
-        goto SIMPLIFY_GCD;
-      }
-    }
-    else
-    {
-      // Print("\n// MwalkNextWeightCC: geaenderter vector liegt nicht in Groebnerkegel! \n");
-      break;
-    }
+    (*diff_weight1)[j] = mpz_get_si(vec[j]);
+  }
+  while(test_w_in_ConeCC(G,diff_weight1))
+  {
+    for(j=0; j<nRing; j++)
+    {
+      (*diff_weight)[j] = (*diff_weight1)[j];
+      mpz_set_si(vec[j], (*diff_weight)[j]);      
+    }
+    for(j=0; j<nRing; j++)
+    {
+      (*diff_weight1)[j] = floor(0.1*(*diff_weight)[j] + 0.5);
+    }
+  }
+  if(MivAbsMax(diff_weight)>10000)
+  {
+    for(j=0; j<nRing; j++)
+    {
+      (*diff_weight1)[j] = (*diff_weight)[j];
+    }
+    j = 0;
+    while(test_w_in_ConeCC(G,diff_weight1))
+    {
+      (*diff_weight)[j] = (*diff_weight1)[j];
+      mpz_set_si(vec[j], (*diff_weight)[j]);
+      j = MivAbsMaxArg(diff_weight1);
+      (*diff_weight1)[j] = floor(0.1*(*diff_weight1)[j] + 0.5);
+    }
+    goto SIMPLIFY_GCD;
   }
 
@@ -2224 +2255 @@
    mpz_clear(t_null);
 
-
-
   if(Overflow_Error == FALSE)
   {
     Overflow_Error = nError;
   }
- rComplete(currRing);
-  for(kkk=0; kkk<IDELEMS(G);kkk++)
-  {
-    poly p=G->m[kkk];
+  rComplete(currRing);
+  for(j=0; j<IDELEMS(G); j++)
+  {
+    poly p=G->m[j];
     while(p!=NULL)
     {
@@ -2273 +2302 @@
 }
 
-/**************************************************************
+/********************************************************************
  * define and execute a new ring which order is (a(vb),a(va),lp,C)  *
- * ************************************************************/
+ * ******************************************************************/
 static void VMrHomogeneous(intvec* va, intvec* vb)
 {
@@ -2427 +2456 @@
   //rChangeCurrRing(r);
 }
-
+//unused
+#if 0
 static ring VMrDefault1(intvec* va)
 {
@@ -2498 +2528 @@
   return r;
 }
-
+#endif
 /****************************************************************
  * define and execute a new ring with ordering (a(va),Wp(vb),C) *
@@ -3128 +3158 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -3884 +3914 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4145 +4175 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4287 +4317 @@
 intvec* Xivlp;
 
-#if 0
-/********************************
- * compute a next weight vector *
- ********************************/
-static intvec* MWalkRandomNextWeight(ideal G, intvec* curr_weight, intvec* target_weight, int weight_rad, int pert_deg)
-{
-  int i, weight_norm;
-  int nV = currRing->N;
-  intvec* next_weight2;
-  intvec* next_weight22 = new intvec(nV);
-  intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
-  if(MivComp(next_weight, target_weight) == 1)
-  {
-    return(next_weight);
-  }
-  else
-  {
-    //compute a perturbed next weight vector "next_weight1"
-    intvec* next_weight1 = MkInterRedNextWeight(MPertVectors(G, MivMatrixOrder(curr_weight), pert_deg), target_weight, G);
-    //Print("\n // size of next_weight1 = %d", sizeof((*next_weight1)));
-
-    //compute a random next weight vector "next_weight2"
-    while(1)
-    {
-      weight_norm = 0;
-      while(weight_norm == 0)
-      {
-        for(i=0; i<nV; i++)
-        {
-          //Print("\n//  next_weight[%d]  = %d", i, (*next_weight)[i]);
-          (*next_weight22)[i] = rand() % 60000 - 30000;
-          weight_norm = weight_norm + (*next_weight22)[i]*(*next_weight22)[i];
-        }
-        weight_norm = 1 + floor(sqrt(weight_norm));
-      }
-
-      for(i=nV-1; i>=0; i--)
-      {
-        if((*next_weight22)[i] < 0)
-        {
-          (*next_weight22)[i] = 1 + (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
-        }
-        else
-        {
-          (*next_weight22)[i] = (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
-        }
-      //Print("\n//  next_weight22[%d]  = %d", i, (*next_weight22)[i]);
-      }
-
-      if(test_w_in_ConeCC(G, next_weight22) == 1)
-      {
-        //Print("\n//MWalkRandomNextWeight: next_weight2 im Kegel\n");
-        next_weight2 = MkInterRedNextWeight(next_weight22, target_weight, G);
-        delete next_weight22;
-        break;
-      }
-    }
-    intvec* result = new intvec(nV);
-    ideal G_test = MwalkInitialForm(G, next_weight);
-    ideal G_test1 = MwalkInitialForm(G, next_weight1);
-    ideal G_test2 = MwalkInitialForm(G, next_weight2);
-
-    // compare next_weights
-    if(IDELEMS(G_test1) < IDELEMS(G_test))
-    {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test1)) // |G_test2| <= |G_test1| < |G_test|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight2)[i];
-        }
-      }
-      else // |G_test1| < |G_test|, |G_test1| < |G_test2|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight1)[i];
-        }
-      }
-    }
-    else
-    {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test)) // |G_test2| <= |G_test| <= |G_test1|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight2)[i];
-        }
-      }
-      else // |G_test| <= |G_test1|, |G_test| < |G_test2|
-      {
-        for(i=0; i<nV; i++)
-        {
-          (*result)[i] = (*next_weight)[i];
-        }
-      }
-    }
-    delete next_weight;
-    delete next_weight1;
-    idDelete(&G_test);
-    idDelete(&G_test1);
-    idDelete(&G_test2);
-    if(test_w_in_ConeCC(G, result) == 1)
-    {
-      delete next_weight2;
-      return result;
-    }
-    else
-    {
-      delete result;
-      return next_weight2;
-    }
-  }
-}
-#endif
 
 /********************************
@@ -4416 +4331 @@
 
   //compute a perturbed next weight vector "next_weight1"
-  //intvec* next_weight1 = MkInterRedNextWeight(MPertVectors(G,MivMatrixOrderRefine(curr_weight,target_weight),pert_deg),target_weight,G);
   intvec* next_weight1 =MkInterRedNextWeight(curr_weight,target_weight,G);
   //compute a random next weight vector "next_weight2"
@@ -4445 +4359 @@
     {
       next_weight2 = MkInterRedNextWeight(next_weight22,target_weight,G);
+      if(MivAbsMax(next_weight2)>1147483647)
+      {
+        for(i=0; i<nV; i++)
+        {
+          (*next_weight22)[i] = (*next_weight2)[i];
+        }
+        i = 0;
+        while(test_w_in_ConeCC(G,next_weight22))
+        {
+          (*next_weight2)[i] = (*next_weight22)[i];
+          i = MivAbsMaxArg(next_weight22);
+          (*next_weight22)[i] = floor(0.1*(*next_weight22)[i] + 0.5);
+        }
+      }
       delete next_weight22;
       break;
@@ -4575 +4503 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     TargetRing = currRing;
@@ -4646 +4574 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4755 +4683 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     F1 = idrMoveR(G, newRing,currRing);
@@ -4786 +4714 @@
       else
       {
-        rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(orig_target_weight));
       }
     KSTD_Finish:
@@ -4884 +4812 @@
       tim = clock();
       /*
-        Print("\n// **** Grï¿œbnerwalk took %d steps and ", nwalk);
+        Print("\n// **** Groebnerwalk took %d steps and ", nwalk);
         PrintS("\n// **** call the rec. Pert. Walk to compute a red GB of:");
         idElements(Gomega, "G_omega");
@@ -4914 +4842 @@
       oldRing = currRing;
 
-      /* create a new ring newRing */
+      // create a new ring newRing
        if (rParameter(currRing) != NULL)
        {
@@ -4921 +4849 @@
        else
        {
-         rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+         rChangeCurrRing(VMrDefault(curr_weight));
        }
       newRing = currRing;
@@ -4947 +4875 @@
       else
       {
-        rChangeCurrRing(VMrDefault(curr_weight));  //Aenderung
+        rChangeCurrRing(VMrDefault(curr_weight));
       }
       newRing = currRing;
@@ -4959 +4887 @@
       M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
       delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
       tstd = tstd + clock() - to;
 
@@ -4968 +4896 @@
 
       to = clock();
-      // compute a representation of the generators of submod (M) with respect to those of mod (Gomega). Gomega is a reduced Groebner basis w.r.t. the current ring.
+      // compute a representation of the generators of submod (M) with respect
+      // to those of mod (Gomega).
+      // Gomega is a reduced Groebner basis w.r.t. the current ring.
       F = MLifttwoIdeal(Gomega2, M1, G);
       tlift = tlift + clock() - to;
@@ -5018 +4948 @@
       else
       {
-        rChangeCurrRing(VMrDefault(target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(target_weight));
       }
       F1 = idrMoveR(G, newRing,currRing);
@@ -5065 +4995 @@
  * THE GROEBNER WALK ALGORITHM *
  *******************************/
-ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M, ring baseRing)
+ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M,
+            ring baseRing, int reduction, int printout)
 {
-  BITSET save1 = si_opt_1; // save current options
-  //si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
-  //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
-  //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  // save current options
+  BITSET save1 = si_opt_1;
+  if(reduction == 0)
+  {
+    // no reduced Groebner basis
+    si_opt_1 &= (~Sy_bit(OPT_REDSB));
+    // not tail reductions
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL));
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
@@ -5111 +5047 @@
 #endif
   rComplete(currRing);
-#ifdef CHECK_IDEAL_MWALK
-    idString(Go,"Go");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+  if(printout > 2)
+  {
+    idString(Go,"//** Mwalk: Go");
+  }
+//#endif
 #ifdef TIME_TEST
   to = clock();
 #endif
-     if(orig_M->length() == nV)
-      {
-        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
-      }
-      else
-      {
-        newRing = VMatrDefault(orig_M);
-      }
+  if(orig_M->length() == nV)
+  {
+    // define a new ring with ordering "(a(curr_weight),lp)
+    newRing = VMrDefault(curr_weight);
+  }
+  else
+  {
+    newRing = VMatrDefault(orig_M);
+  }
   rChangeCurrRing(newRing);
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
@@ -5140 +5080 @@
     to = clock();
 #endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(G,"G");
-#endif
-    Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G,"//** Mwalk: G");
+    }
+//#endif
+    // compute an initial form ideal of <G> w.r.t. "curr_vector"
+    Gomega = MwalkInitialForm(G, curr_weight);
 #ifdef TIME_TEST
-    tif = tif + clock()-to; //time for computing initial form ideal
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(Gomega,"Gomega");
-#endif
+    //time for computing initial form ideal
+    tif = tif + clock()-to;
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mwalk: Gomega");
+    }
+//#endif
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(curr_weight) == 0)
@@ -5164 +5112 @@
       if(orig_M->length() == nV)
       {
-        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+        // define a new ring with ordering "(a(curr_weight),lp)
+        newRing = VMrDefault(curr_weight);
       }
       else
@@ -5175 +5124 @@
      if(target_M->length() == nV)
      {
-       newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       newRing = VMrRefine(curr_weight,target_weight);
      }
      else
      {
+       //define a new ring with matrix ordering
        newRing = VMatrRefine(target_M,curr_weight);
      }
@@ -5199 +5150 @@
 #endif
     idSkipZeroes(M);
-#ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: computed M.\n");
-    idString(M, "M");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M, "//** Mwalk: M");
+    }
+//#endif
     //change the ring to baseRing
     rChangeCurrRing(baseRing);
@@ -5212 +5165 @@
     to = clock();
 #endif
-    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega), where Gomega is a reduced Groebner basis w.r.t. the current ring
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
+    // where Gomega is a reduced Groebner basis w.r.t. the current ring
     F = MLifttwoIdeal(Gomega2, M1, G);
 #ifdef TIME_TEST
     tlift = tlift + clock() - to;
 #endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(F, "F");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F, "//** Mwalk: F");
+    }
+//#endif
     idDelete(&Gomega2);
     idDelete(&M1);
@@ -5229 +5186 @@
     to = clock();
 #endif
-    //G = kStd(F1,NULL,testHomog,NULL,NULL,0,0,NULL);
+
 #ifdef TIME_TEST
     tstd = tstd + clock() - to;
 #endif
     idSkipZeroes(G);
-#ifdef CHECK_IDEAL_MWALK
-    idString(G, "G");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G, "//** Mwalk: G");
+    }
+//#endif
 #ifdef TIME_TEST
     to = clock();
@@ -5244 +5204 @@
     tnw = tnw + clock() - to;
 #endif
-#ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
-#endif
-    if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1)// || test_w_in_ConeCC(G, target_weight) == 1 || MivComp(next_weight,curr_weight) == 1)
-    {
-#ifdef CHECK_IDEAL_MWALK
-      PrintS("\n//** Mwalk: entering last cone.\n");
-#endif
+//#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
+    if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1 || test_w_in_ConeCC(G, target_weight) == 1)
+    {
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 0)
+      {
+        PrintS("\n//** Mwalk: entering last cone.\n");
+      }
+//#endif
       Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
       if(target_M->length() == nV)
@@ -5264 +5230 @@
       Gomega1 = idrMoveR(Gomega, baseRing,currRing);
       idDelete(&Gomega);
-#ifdef CHECK_IDEAL_MWALK
-      idString(Gomega1, "Gomega");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega1, "//** Mwalk: Gomega");
+      }
+//#endif
       M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#ifdef CHECK_IDEAL_MWALK
-      idString(M,"M");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(M,"//** Mwalk: M");
+      }
+//#endif
       rChangeCurrRing(baseRing);
       M1 =  idrMoveR(M, newRing,currRing);
@@ -5277 +5249 @@
       idDelete(&Gomega1);
       F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef CHECK_IDEAL_MWALK
-      idString(F,"F");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mwalk: F");
+    }
+//#endif
       idDelete(&Gomega2);
       idDelete(&M1);
@@ -5291 +5266 @@
       to = clock();
 #endif
- //     if(si_opt_1 == (Sy_bit(OPT_REDSB)))
-  //    {
-        G = kInterRedCC(G,NULL); //reduce the Groebner basis <G> w.r.t. currRing, if option(redSB) is set
-  //    }
+      //interreduce the Groebner basis <G> w.r.t. currRing
+      G = kInterRedCC(G,NULL);
 #ifdef TIME_TEST
       tred = tred + clock() - to;
@@ -5301 +5274 @@
       delete next_weight;
       break;
-#ifdef CHECK_IDEAL_MWALK
-      PrintS("\n//** Mwalk: last cone.\n");
-#endif
-    }
-#ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: update weight vectors.\n");
-#endif
+    }
     for(i=nV-1; i>=0; i--)
     {
@@ -5318 +5285 @@
   ideal result = idrMoveR(G,baseRing,currRing);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
   delete tmp_weight;
   delete ivNull;
@@ -5328 +5292 @@
 #endif
 #ifdef TIME_TEST
-  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-  Print("\n//** Mwalk: Ergebnis.\n");
   //Print("\n// pSetm_Error = (%d)", ErrorCheck());
   //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
 #endif
+  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   return(result);
 }
 
-// 07.11.2012
-// THE RANDOM WALK ALGORITHM  ideal Go, intvec* orig_M, intvec* target_M, ring baseRing
-ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg, ring baseRing)
+// THE RANDOM WALK ALGORITHM
+ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg,
+             int reduction, int printout)
 {
   BITSET save1 = si_opt_1; // save current options
-  //si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
-  //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
-  //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+    //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
@@ -5354 +5320 @@
 #endif
   nstep=0;
-  int i,nwalk,endwalks = 0;
-  int nV = baseRing->N;
+  int i,polylength,nwalk,endwalks = 0;
+  int nV = currRing->N;
 
   ideal Gomega, M, F, Gomega1, Gomega2, M1; //, F1;
   ring newRing;
-  ring XXRing = baseRing;
+  ring baseRing = currRing;
+  ring XXRing = currRing;
   intvec* ivNull = new intvec(nV);
   intvec* curr_weight = new intvec(nV);
@@ -5365 +5332 @@
   intvec* exivlp = Mivlp(nV);
   intvec* tmp_weight = new intvec(nV);
+  intvec* next_weight= new intvec(nV);
   for(i=0; i<nV; i++)
   {
@@ -5385 +5353 @@
 #endif
   rComplete(currRing);
-#ifdef CHECK_IDEAL_MWALK
-    idString(Go,"Go");
-#endif
 #ifdef TIME_TEST
   to = clock();
 #endif
-     if(orig_M->length() == nV)
-      {
-        newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
-      }
-      else
-      {
-        newRing = VMatrDefault(orig_M);
-      }
+  if(orig_M->length() == nV)
+  {
+    newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+  }
+  else
+  {
+    newRing = VMatrDefault(orig_M);
+  }
   rChangeCurrRing(newRing);
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
@@ -5414 +5379 @@
     to = clock();
 #endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(G,"G");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G,"//** Mrwalk: G");
+    }
+//#endif
     Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
 #ifdef TIME_TEST
     tif = tif + clock()-to; //time for computing initial form ideal
 #endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(Gomega,"Gomega");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mrwalk: Gomega");
+    }
+//#endif
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(curr_weight) == 0)
@@ -5473 +5446 @@
 #endif
     idSkipZeroes(M);
-#ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: computed M.\n");
-    idString(M, "M");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M, "//** Mrwalk: M");
+    }
+//#endif
     //change the ring to baseRing
     rChangeCurrRing(baseRing);
@@ -5486 +5461 @@
     to = clock();
 #endif
-    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega), where Gomega is a reduced Groebner basis w.r.t. the current ring
+    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega),
+    // where Gomega is a reduced Groebner basis w.r.t. the current ring
     F = MLifttwoIdeal(Gomega2, M1, G);
 #ifdef TIME_TEST
     tlift = tlift + clock() - to;
 #endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(F, "F");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F, "//** Mrwalk: F");
+    }
+//#endif
     idDelete(&Gomega2);
     idDelete(&M1);
@@ -5502 +5481 @@
 #ifdef TIME_TEST
     to = clock();
-#endif
-    //G = kStd(F1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#ifdef TIME_TEST
     tstd = tstd + clock() - to;
 #endif
     idSkipZeroes(G);
-#ifdef CHECK_IDEAL_MWALK
-    idString(G, "G");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G, "//** Mrwalk: G");
+    }
+//#endif
 #ifdef TIME_TEST
     to = clock();
 #endif
-    intvec* next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, pert_deg);//next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+    next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_weight;
+      next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, pert_deg);
+    }
 #ifdef TIME_TEST
     tnw = tnw + clock() - to;
 #endif
-#ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
-#endif
+//#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
     if(MivComp(next_weight, ivNull) == 1 || MivComp(target_weight,curr_weight) == 1)// || test_w_in_ConeCC(G, target_weight) == 1 || MivComp(next_weight,curr_weight) == 1)
     {
@@ -5527 +5516 @@
 #endif
       Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega, "//** Mrwalk: Gomega");
+      }
+//#endif
       if(target_M->length() == nV)
       {
@@ -5538 +5533 @@
       Gomega1 = idrMoveR(Gomega, baseRing,currRing);
       idDelete(&Gomega);
-#ifdef CHECK_IDEAL_MWALK
-      idString(Gomega1, "Gomega");
-#endif
       M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#ifdef CHECK_IDEAL_MWALK
-      idString(M,"M");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(M,"//** Mrwalk: M");
+      }
+//#endif
       rChangeCurrRing(baseRing);
       M1 =  idrMoveR(M, newRing,currRing);
@@ -5551 +5546 @@
       idDelete(&Gomega1);
       F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef CHECK_IDEAL_MWALK
-      idString(F,"F");
-#endif
       idDelete(&Gomega2);
       idDelete(&M1);
@@ -5560 +5552 @@
       idDelete(&F);
       baseRing = currRing;
-      si_opt_1 = save1; //set original options, e. g. option(RedSB)
       idSkipZeroes(G);
 #ifdef TIME_TEST
       to = clock();
 #endif
- //     if(si_opt_1 == (Sy_bit(OPT_REDSB)))
-  //    {
-        //G = kInterRedCC(G,NULL); //reduce the Groebner basis <G> w.r.t. currRing, if option(redSB) is set
-  //    }
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(G,"//** Mrwalk: G");
+      }
+/*#endif
+      if(si_opt_1 == (Sy_bit(OPT_REDSB)))
+      {*/
+        G = kInterRedCC(G,NULL); //interreduce the Groebner basis <G> w.r.t. currRing
+//      }
 #ifdef TIME_TEST
       tred = tred + clock() - to;
@@ -5575 +5572 @@
       delete next_weight;
       break;
-#ifdef CHECK_IDEAL_MWALK
-      PrintS("\n//** Mwalk: last cone.\n");
-#endif
-    }
-#ifdef CHECK_IDEAL_MWALK
-    PrintS("\n//** Mwalk: update weight vectors.\n");
-#endif
+    }
     for(i=nV-1; i>=0; i--)
     {
@@ -5589 +5580 @@
     delete next_weight;
   }
+  baseRing = currRing;
   rChangeCurrRing(XXRing);
   ideal result = idrMoveR(G,baseRing,currRing);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete tmp_weight;
   delete ivNull;
@@ -5601 +5591 @@
   delete last_omega;
 #endif
+  Print("\n//** Mrwalk: Groebner Walk took %d steps.\n", nstep);
 #ifdef TIME_TEST
-  Print("\n//** Mwalk: Groebner Walk took %d steps.\n", nstep);
   TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-  Print("\n//** Mwalk: Ergebnis.\n");
   //Print("\n// pSetm_Error = (%d)", ErrorCheck());
   //Print("\n// Overflow_Error? (%d)\n", Overflow_Error);
@@ -5751 +5740 @@
 // use kStd, if nP = 0, else call LastGB
 ideal Mpwalk(ideal Go, int op_deg, int tp_deg,intvec* curr_weight,
-             intvec* target_weight, int nP)
+             intvec* target_weight, int nP, int reduction, int printout)
 {
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+    //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  }
   Set_Error(FALSE  );
   Overflow_Error = FALSE;
@@ -5790 +5786 @@
   ring XXRing = currRing;
 
-
   to = clock();
-  /* perturbs the original vector */
+  // perturbs the original vector
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
   {
@@ -5809 +5804 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 1
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     G = idrMoveR(Go, XXRing,currRing);
@@ -5824 +5819 @@
   ring HelpRing = currRing;
 
-  /* perturbs the target weight vector */
+  // perturbs the target weight vector
   if(tp_deg > 1 && tp_deg <= nV)
   {
@@ -5830 +5825 @@
       DefRingPar(target_weight);
     else
-      rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 2
+      rChangeCurrRing(VMrDefault(target_weight));
 
     TargetRing = currRing;
@@ -5852 +5847 @@
     G = idrMoveR(ssG, TargetRing,currRing);
   }
-  /*
-    Print("\n// Perturbationwalkalg. vom Gradpaar (%d,%d):",op_deg,tp_deg);
-    ivString(curr_weight, "new sigma");
-    ivString(target_weight, "new tau");
-  */
+    if(printout > 0)
+    {
+      Print("\n//** Mpwalk: Perturbation Walk of degree (%d,%d):",op_deg,tp_deg);
+      ivString(curr_weight, "//** Mpwalk: new current weight");
+      ivString(target_weight, "//** Mpwalk: new target weight");
+    }
   while(1)
   {
@@ -5864 +5860 @@
        "curr_weight" */
     Gomega = MwalkInitialForm(G, curr_weight);
-
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega,"//** Mpwalk: Gomega");
+      }
+//#endif
 
 #ifdef ENDWALKS
-    if(endwalks == 1){
+    if(endwalks == 1)
+    {
       Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
       idElements(G, "G");
-      // idElements(Gomega, "Gw");
       headidString(G, "G");
-      //headidString(Gomega, "Gw");
     }
 #endif
@@ -5891 +5891 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 3
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     newRing = currRing;
@@ -5918 +5918 @@
     M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
     delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(M,"//** Mpwalk: M");
+      }
+//#endif
 
     if(endwalks == 1){
@@ -5934 +5940 @@
     M1 =  idrMoveR(M, newRing,currRing);
     Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
-
-    //if(endwalks==1)  PrintS("\n// Lifting is working:..");
 
     to=clock();
@@ -5947 +5951 @@
       xtlift=clock()-to;
 
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mpwalk: F");
+    }
+//#endif
+
     idDelete(&M1);
     idDelete(&Gomega2);
@@ -5954 +5965 @@
     rChangeCurrRing(newRing);
     F1 = idrMoveR(F, oldRing,currRing);
-
-    //if(endwalks==1)PrintS("\n// InterRed is working now:");
 
     to=clock();
@@ -5971 +5980 @@
 
     to=clock();
-    /* compute a next weight vector */
+    // compute a next weight vector
     next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
     tnw=tnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
-#endif
+//#ifdef PRINT_VECTORS
+    if(printout > 2)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
 
     if(Overflow_Error == TRUE)
@@ -6014 +6026 @@
         DefRingPar(orig_target);
       else
-        rChangeCurrRing(VMrDefault(orig_target)); //Aenderung
+        rChangeCurrRing(VMrDefault(orig_target));
 
     TargetRing=currRing;
@@ -6068 +6080 @@
     Eresult = idrMoveR(G, newRing,currRing);
   }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete ivNull;
   if(tp_deg != 1)
@@ -6082 +6095 @@
              tnw+xtnw);
 
-  Print("\n// pSetm_Error = (%d)", ErrorCheck());
-  Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep,  Overflow_Error);
-#endif
+  //Print("\n// pSetm_Error = (%d)", ErrorCheck());
+  //Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep,  Overflow_Error);
+#endif
+  Print("\n//** Mpwalk: Perturbation Walk took %d steps.\n", nstep);
+  return(Eresult);
+}
+
+/*******************************************************
+ * THE PERTURBATION WALK ALGORITHM WITH RANDOM ELEMENT *
+ *******************************************************/
+ideal Mprwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad,
+              int op_deg, int tp_deg, int nP, int reduction, int printout)
+{
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+    //si_opt_1|=(Sy_bit(OPT_REDTAIL)|Sy_bit(OPT_REDSB));
+  }
+  Set_Error(FALSE);
+  Overflow_Error = FALSE;
+  //Print("// pSetm_Error = (%d)", ErrorCheck());
+
+  clock_t  tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
+  xtextra=0;
+  xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
+  tinput = clock();
+
+  clock_t tim;
+
+  nstep = 0;
+  int i, ntwC=1, ntestw=1, polylength, nV = currRing->N;
+  int endwalks=0;
+
+  ideal Gomega, M, F, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
+  ring newRing, oldRing, TargetRing;
+  intvec* iv_M_dp;
+  intvec* iv_M_lp;
+  intvec* exivlp = Mivlp(nV);
+  intvec* curr_weight = new intvec(nV);
+  intvec* target_weight = new intvec(nV);
+  for(i=0; i<nV; i++)
+  {
+    (*curr_weight)[i] = (*orig_M)[i];
+    (*target_weight)[i] = (*target_M)[i];
+  }
+  intvec* orig_target = target_weight;
+  intvec* pert_target_vector = target_weight;
+  intvec* ivNull = new intvec(nV);
+  intvec* iv_dp = MivUnit(nV);// define (1,1,...,1)
+#ifndef BUCHBERGER_ALG
+  intvec* hilb_func;
+#endif
+  intvec* next_weight;
+
+  // to avoid (1,0,...,0) as the target vector
+  intvec* last_omega = new intvec(nV);
+  for(i=nV-1; i>0; i--)
+    (*last_omega)[i] = 1;
+  (*last_omega)[0] = 10000;
+
+  ring XXRing = currRing;
+
+  to = clock();
+  // perturbs the original vector
+  if(orig_M->length() == nV)
+  {
+    if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
+    {
+      G = MstdCC(Go);
+      tostd = clock()-to;
+      if(op_deg != 1)
+      {
+        iv_M_dp = MivMatrixOrderdp(nV);
+        //ivString(iv_M_dp, "iv_M_dp");
+        curr_weight = MPertVectors(G, iv_M_dp, op_deg);
+      }
+    }
+    else
+    {
+      //define ring order := (a(curr_weight),lp);
+      if (rParameter(currRing) != NULL)
+        DefRingPar(curr_weight);
+      else
+        rChangeCurrRing(VMrDefault(curr_weight));
+
+      G = idrMoveR(Go, XXRing,currRing);
+      G = MstdCC(G);
+      tostd = clock()-to;
+      if(op_deg != 1)
+      {
+        iv_M_dp = MivMatrixOrder(curr_weight);
+        curr_weight = MPertVectors(G, iv_M_dp, op_deg);
+      }
+    }
+  }
+  else
+  {
+    rChangeCurrRing(VMatrDefault(orig_M));
+    G = idrMoveR(Go, XXRing,currRing);
+    G = MstdCC(G);
+    tostd = clock()-to;
+    if(op_deg != 1)
+    {
+      curr_weight = MPertVectors(G, orig_M, op_deg);
+    }
+  }
+
+  delete iv_dp;
+  if(op_deg != 1) delete iv_M_dp;
+
+  ring HelpRing = currRing;
+
+  // perturbs the target weight vector
+  if(target_M->length() == nV)
+  {
+    if(tp_deg > 1 && tp_deg <= nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(target_weight);
+      else
+        rChangeCurrRing(VMrDefault(target_weight));
+
+      TargetRing = currRing;
+      ssG = idrMoveR(G,HelpRing,currRing);
+      if(MivSame(target_weight, exivlp) == 1)
+      {
+        iv_M_lp = MivMatrixOrderlp(nV);
+        //ivString(iv_M_lp, "iv_M_lp");
+        //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
+        target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
+      }
+      else
+      {
+        iv_M_lp = MivMatrixOrder(target_weight);
+        //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
+        target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
+      }
+      delete iv_M_lp;
+      pert_target_vector = target_weight;
+      rChangeCurrRing(HelpRing);
+      G = idrMoveR(ssG, TargetRing,currRing);
+    }
+  }
+  else
+  {
+    if(tp_deg > 1 && tp_deg <= nV)
+    {
+      rChangeCurrRing(VMatrDefault(target_M));
+      TargetRing = currRing;
+      ssG = idrMoveR(G,HelpRing,currRing);
+      target_weight = MPertVectors(ssG, target_M, tp_deg);
+    }
+  }
+  if(printout > 0)
+  {
+    Print("\n//** Mprwalk: Random Perturbation Walk of degree (%d,%d):",op_deg,tp_deg);
+    ivString(curr_weight, "//** Mprwalk: new current weight");
+    ivString(target_weight, "//** Mprwalk: new target weight");
+  }
+  while(1)
+  {
+    nstep ++;
+    to = clock();
+    /* compute an initial form ideal of <G> w.r.t. the weight vector
+       "curr_weight" */
+    Gomega = MwalkInitialForm(G, curr_weight);
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mprwalk: Gomega");
+    }
+//#endif
+    polylength = lengthpoly(Gomega);
+#ifdef ENDWALKS
+    if(endwalks == 1)
+    {
+      Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      idElements(G, "G");
+      headidString(G, "G");
+    }
+#endif
+
+    tif = tif + clock()-to;
+
+#ifndef  BUCHBERGER_ALG
+    if(isNolVector(curr_weight) == 0)
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
+    else
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
+#endif // BUCHBERGER_ALG
+
+    oldRing = currRing;
+
+    if(target_M->length() == nV)
+    {
+      // define a new ring with ordering "(a(curr_weight),lp)
+      if (rParameter(currRing) != NULL)
+        DefRingPar(curr_weight);
+      else
+        rChangeCurrRing(VMrDefault(curr_weight));
+    }
+    else
+    {
+      rChangeCurrRing(VMatrRefine(target_M,curr_weight));
+    }
+    newRing = currRing;
+    Gomega1 = idrMoveR(Gomega, oldRing,currRing);
+
+#ifdef ENDWALKS
+    if(endwalks==1)
+    {
+      Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      idElements(Gomega1, "Gw");
+      headidString(Gomega1, "headGw");
+      PrintS("\n// compute a rGB of Gw:\n");
+
+#ifndef  BUCHBERGER_ALG
+      ivString(hilb_func, "w");
+#endif
+    }
+#endif
+
+    tim = clock();
+    to = clock();
+    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
+#ifdef  BUCHBERGER_ALG
+    M = MstdhomCC(Gomega1);
+#else
+    M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
+    delete hilb_func;
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(M,"//** Mprwalk: M");
+    }
+//#endif
+
+    if(endwalks == 1)
+    {
+      xtstd = xtstd+clock()-to;
+#ifdef ENDWALKS
+      Print("\n// time for the last std(Gw)  = %.2f sec\n",
+            ((double) clock())/1000000 -((double)tim) /1000000);
+#endif
+    }
+    else
+      tstd=tstd+clock()-to;
+
+    /* change the ring to oldRing */
+    rChangeCurrRing(oldRing);
+    M1 =  idrMoveR(M, newRing,currRing);
+    Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
+
+    to=clock();
+    /* compute a representation of the generators of submod (M)
+       with respect to those of mod (Gomega).
+       Gomega is a reduced Groebner basis w.r.t. the current ring */
+    F = MLifttwoIdeal(Gomega2, M1, G);
+    if(endwalks != 1)
+      tlift = tlift+clock()-to;
+    else
+      xtlift=clock()-to;
+
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mprwalk: F");
+    }
+//#endif
+
+    idDelete(&M1);
+    idDelete(&Gomega2);
+    idDelete(&G);
+
+    /* change the ring to newRing */
+    rChangeCurrRing(newRing);
+    F1 = idrMoveR(F, oldRing,currRing);
+
+    to=clock();
+    /* reduce the Groebner basis <G> w.r.t. new ring */
+    G = kInterRedCC(F1, NULL);
+    if(endwalks != 1)
+      tred = tred+clock()-to;
+    else
+      xtred=clock()-to;
+
+    idDelete(&F1);
+
+    if(endwalks == 1)
+      break;
+
+    to=clock();
+    // compute a next weight vector
+    next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_weight;
+      next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, op_deg);
+    }
+    tnw=tnw+clock()-to;
+//#ifdef PRINT_VECTORS
+    if(printout > 2)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
+
+    if(Overflow_Error == TRUE)
+    {
+      ntwC = 0;
+      //ntestomega = 1;
+      //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      //idElements(G, "G");
+      delete next_weight;
+      goto FINISH_160302;
+    }
+    if(MivComp(next_weight, ivNull) == 1){
+      newRing = currRing;
+      delete next_weight;
+      //Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+      break;
+    }
+    if(MivComp(next_weight, target_weight) == 1)
+      endwalks = 1;
+
+    for(i=nV-1; i>=0; i--)
+      (*curr_weight)[i] = (*next_weight)[i];
+
+    delete next_weight;
+  }//while
+
+  if(tp_deg != 1)
+  {
+    FINISH_160302:
+    if(target_M->length() == nV)
+    {
+      if(MivSame(orig_target, exivlp) == 1)
+        if (rParameter(currRing) != NULL)
+          DefRingParlp();
+        else
+          VMrDefaultlp();
+      else
+        if (rParameter(currRing) != NULL)
+          DefRingPar(orig_target);
+        else
+          rChangeCurrRing(VMrDefault(orig_target));
+    }
+    else
+    {
+      rChangeCurrRing(VMatrDefault(target_M));
+    }
+    TargetRing=currRing;
+    F1 = idrMoveR(G, newRing,currRing);
+#ifdef CHECK_IDEAL
+      headidString(G, "G");
+#endif
+
+    // check whether the pertubed target vector stays in the correct cone
+    if(ntwC != 0){
+      ntestw = test_w_in_ConeCC(F1, pert_target_vector);
+    }
+
+    if( ntestw != 1 || ntwC == 0)
+    {
+      /*
+      if(ntestw != 1){
+        ivString(pert_target_vector, "tau");
+        PrintS("\n// ** perturbed target vector doesn't stay in cone!!");
+        Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
+        idElements(F1, "G");
+      }
+      */
+      // LastGB is "better" than the kStd subroutine
+      to=clock();
+      ideal eF1;
+      if(nP == 0 || tp_deg == 1 || MivSame(orig_target, exivlp) != 1 || target_M->length() != nV){
+        // PrintS("\n// ** calls \"std\" to compute a GB");
+        eF1 = MstdCC(F1);
+        idDelete(&F1);
+      }
+      else {
+        // PrintS("\n// ** calls \"LastGB\" to compute a GB");
+        rChangeCurrRing(newRing);
+        ideal F2 = idrMoveR(F1, TargetRing,currRing);
+        eF1 = LastGB(F2, curr_weight, tp_deg-1);
+        F2=NULL;
+      }
+      xtextra=clock()-to;
+      ring exTargetRing = currRing;
+
+      rChangeCurrRing(XXRing);
+      Eresult = idrMoveR(eF1, exTargetRing,currRing);
+    }
+    else{
+      rChangeCurrRing(XXRing);
+      Eresult = idrMoveR(F1, TargetRing,currRing);
+    }
+  }
+  else {
+    rChangeCurrRing(XXRing);
+    Eresult = idrMoveR(G, newRing,currRing);
+  }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
+  delete ivNull;
+  if(tp_deg != 1)
+    delete target_weight;
+
+  if(op_deg != 1 )
+    delete curr_weight;
+
+  delete exivlp;
+  delete last_omega;
+
+#ifdef TIME_TEST
+  TimeStringFractal(tinput, tostd, tif+xtif, tstd+xtstd,0, tlift+xtlift, tred+xtred,
+             tnw+xtnw);
+
+  //Print("\n// pSetm_Error = (%d)", ErrorCheck());
+  //Print("\n// It took %d steps and Overflow_Error? (%d)\n", nstep,  Overflow_Error);
+#endif
+  Print("\n//** Mprwalk: Perturbation Walk took %d steps.\n", nstep);
   return(Eresult);
 }
@@ -6110 +6546 @@
  * Perturb the start weight vector at the top level, i.e. nlev = 1     *
  ***********************************************************************/
-static ideal rec_fractal_call(ideal G, int nlev, intvec* omtmp)
+static ideal rec_fractal_call(ideal G, int nlev, intvec* ivtarget, int printout)
 {
   Overflow_Error =  FALSE;
@@ -6127 +6563 @@
   intvec* next_vect;
   intvec* omega2 = new intvec(nV);
+  intvec* omtmp = new intvec(nV);
   intvec* altomega = new intvec(nV);
 
+  for(i = nV -1; i>0; i--)
+  {
+    (*omtmp)[i] = (*ivtarget)[i];
+  }
   //BOOLEAN isnewtarget = FALSE;
 
@@ -6169 +6610 @@
     NEXT_VECTOR_FRACTAL:
     to=clock();
-    /* determine the next border */
+    // determine the next border
     next_vect = MkInterRedNextWeight(omega,omega2,G);
     xtnw=xtnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(omega, omega2, next_vect);
-#endif
+
     oRing = currRing;
 
-    /* We only perturb the current target vector at the recursion  level 1 */
+    // We only perturb the current target vector at the recursion  level 1
     if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
       if (MivComp(next_vect, omega2) == 1)
       {
-        /* to dispense with taking initial (and lifting/interreducing
-           after the call of recursion */
-        //Print("\n\n// ** Perturb the both vectors with degree %d with",nlev);
-        //idElements(G, "G");
+        // to dispense with taking initial (and lifting/interreducing
+        // after the call of recursion
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Perturb the both vectors with degree %d.",nlev);
+          //idElements(G, "G");
+        }
 
         Xngleich = 1;
         nlev +=1;
 
-        if (rParameter(currRing) != NULL)
-          DefRingPar(omtmp);
+        if(ivtarget->length() == nV)
+        {
+          if (rParameter(currRing) != NULL)
+            DefRingPar(omtmp);
+          else
+            rChangeCurrRing(VMrDefault(omtmp));
+        }
         else
-          rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung3
-
+        {
+          rChangeCurrRing(VMatrDefault(ivtarget));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
 
-        /* perturb the original target vector w.r.t. the current GB */
-        delete Xtau;
-        Xtau = NewVectorlp(Gt);
+        // perturb the original target vector w.r.t. the current GB
+        if(ivtarget->length() == nV)
+        {
+          delete Xtau;
+          Xtau = NewVectorlp(Gt);
+        }
+        else
+        {
+          delete Xtau;
+          Xtau = Mfpertvector(Gt,ivtarget);
+        }
 
         rChangeCurrRing(oRing);
         G = idrMoveR(Gt, testring,currRing);
 
-        /* perturb the current vector w.r.t. the current GB */
+        // perturb the current vector w.r.t. the current GB
         Mwlp = MivWeightOrderlp(omega);
         Xsigma = Mfpertvector(G, Mwlp);
@@ -6222 +6678 @@
         next_vect = MkInterRedNextWeight(omega,omega2,G);
         xtnw=xtnw+clock()-to;
-
-#ifdef PRINT_VECTORS
+      }
+//#ifdef PRINT_VECTORS
+      if(printout > 0)
+      {
         MivString(omega, omega2, next_vect);
-#endif
-      }
-
+      }
+//#endif
 
     /* check whether the the computed vector is in the correct cone */
@@ -6236 +6693 @@
     {
       delete next_vect;
-      if (rParameter(currRing) != NULL)
-      {
-        DefRingPar(omtmp);
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
       }
       else
       {
-        rChangeCurrRing(VMrDefault1(omtmp)); // Aenderung4
+        rChangeCurrRing(VMatrDefault(ivtarget));
       }
 #ifdef TEST_OVERFLOW
@@ -6248 +6708 @@
       Gt = NULL; return(Gt);
 #endif
-
-      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: applying Buchberger's algorithm in ring r = %s;",
+              rString(currRing));
+      }
       to=clock();
       Gt = idrMoveR(G, oRing,currRing);
@@ -6258 +6721 @@
       delete omega2;
       delete altomega;
-
-      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
-      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
+
       nnflow ++;
 
@@ -6277 +6744 @@
     if (MivComp(next_vect, XivNull) == 1)
     {
-      if (rParameter(currRing) != NULL)
-        DefRingPar(omtmp);
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
       else
-        rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung5
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
 
       testring = currRing;
@@ -6289 +6763 @@
         delete next_vect;
         delete altomega;
-        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
-        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
-
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         return (Gt);
       }
@@ -6302 +6779 @@
         //07.08.03
         //ivString(Xtau, "old Xtau");
-        intvec* Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
 #ifdef TEST_OVERFLOW
       if(Overflow_Error == TRUE)
@@ -6330 +6815 @@
 
       FRACTAL_MSTDCC:
-        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: apply Buchberger's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
         to=clock();
         G = MstdCC(Gt);
@@ -6338 +6827 @@
 
         // update the original target vector w.r.t. the current GB
-        if(MivSame(Xivinput, Xivlp) == 1)
-          if (rParameter(currRing) != NULL)
-            DefRingParlp();
+        if(ivtarget->length() == nV)
+        {
+          if(MivSame(Xivinput, Xivlp) == 1)
+            if (rParameter(currRing) != NULL)
+              DefRingParlp();
+            else
+              VMrDefaultlp();
           else
-            VMrDefaultlp();
+            if (rParameter(currRing) != NULL)
+              DefRingPar(Xivinput);
+            else
+              rChangeCurrRing(VMrDefault(Xivinput));
+        }
         else
-          if (rParameter(currRing) != NULL)
-            DefRingPar(Xivinput);
-          else
-            rChangeCurrRing(VMrDefault1(Xivinput)); //Aenderung6
-
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
@@ -6361 +6856 @@
         delete next_vect;
         delete altomega;
-        /*
-          Print("\n// Leaving the %d-th recursion with %d steps,", nlev,nwalks);
-          Print(" ** Overflow_Error? (%d)", Overflow_Error);
-        */
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         if(Overflow_Error == TRUE)
           nnflow ++;
@@ -6383 +6880 @@
     Gomega = MwalkInitialForm(G, omega);
     xtif=xtif+clock()-to;
-
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_fractal_call: Gomega");
+    }
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(omega) == 0)
@@ -6390 +6890 @@
       hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
 #endif // BUCHBERGER_ALG
-
-    if (rParameter(currRing) != NULL)
-      DefRingPar(omega);
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
     else
-      rChangeCurrRing(VMrDefault1(omega)); //Aenderung7
-
+    {
+      rChangeCurrRing(VMatrRefine(ivtarget,omega));
+    }
     Gomega1 = idrMoveR(Gomega, oRing,currRing);
 
-    /* Maximal recursion depth, to compute a red. GB */
-    /* Fractal walk with the alternative recursion */
-    /* alternative recursion */
+    // Maximal recursion depth, to compute a red. GB
+    // Fractal walk with the alternative recursion
+    // alternative recursion
     // if(nlev == nV || lengthpoly(Gomega1) == 0)
     if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
       //if(nlev == nV) // blind recursion
     {
-      /*
-      if(Xnlev != nV)
-      {
-        Print("\n// ** Xnlev = %d", Xnlev);
-        ivString(Xtau, "Xtau");
-      }
-      */
       to=clock();
 #ifdef  BUCHBERGER_ALG
@@ -6421 +6919 @@
       xtstd=xtstd+clock()-to;
     }
-    else {
+    else
+    {
       rChangeCurrRing(oRing);
       Gomega1 = idrMoveR(Gomega1, oRing,currRing);
-      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
-    }
-
-    //convert a Groebner basis from a ring to another ring,
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
     new_ring = currRing;
 
@@ -6435 +6937 @@
 
     to=clock();
-    /* Lifting process */
+    // Lifting process
     F = MLifttwoIdeal(Gomega2, Gresult1, G);
     xtlift=xtlift+clock()-to;
+    if(printout > 2)
+    {
+      idString(F,"//** rec_fractal_call: F");
+    }
     idDelete(&Gresult1);
     idDelete(&Gomega2);
@@ -6456 +6962 @@
  * Perturb the start weight vector at the top level with random element *
  ************************************************************************/
-static ideal rec_r_fractal_call(ideal G, int nlev, intvec* omtmp, int weight_rad)
+static ideal rec_r_fractal_call(ideal G, int nlev, intvec* ivtarget,
+                int weight_rad, int printout)
 {
   Overflow_Error =  FALSE;
   //Print("\n\n// Entering the %d-th recursion:", nlev);
 
-  int i, nV = currRing->N;
+  int i, polylength, nV = currRing->N;
   ring new_ring, testring;
   //ring extoRing;
@@ -6473 +6980 @@
   intvec* next_vect;
   intvec* omega2 = new intvec(nV);
+  intvec* omtmp = new intvec(nV);
   intvec* altomega = new intvec(nV);
 
   //BOOLEAN isnewtarget = FALSE;
 
+  for(i = nV -1; i>0; i--)
+  {
+    (*omtmp)[i] = (*ivtarget)[i];
+  }
   // to avoid (1,0,...,0) as the target vector (Hans)
   intvec* last_omega = new intvec(nV);
@@ -6516 +7028 @@
     to=clock();
     /* determine the next border */
-    next_vect = MWalkRandomNextWeight(G, omega,omega2, weight_rad, 1+nlev);
-    //next_vect = MkInterRedNextWeight(omega,omega2,G);
+    next_vect = MkInterRedNextWeight(omega,omega2,G);
+    if(polylength > 0)
+    {
+      //there is a polynomial in Gomega with at least 3 monomials,
+      //low-dimensional facet of the cone
+      delete next_vect;
+      next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,1+nlev);
+      if(isNolVector(next_vect))
+      {
+        delete next_vect;
+        next_vect = MkInterRedNextWeight(omega,omega2,G);
+      }
+    }
     xtnw=xtnw+clock()-to;
-#ifdef PRINT_VECTORS
-    MivString(omega, omega2, next_vect);
-#endif
+
     oRing = currRing;
 
-    /* We only perturb the current target vector at the recursion  level 1 */
+    // We only perturb the current target vector at the recursion  level 1
     if(Xngleich == 0 && nlev == 1) //(ngleich == 0) important, e.g. ex2, ex3
       if (MivComp(next_vect, omega2) == 1)
       {
-        /* to dispense with taking initial (and lifting/interreducing
-           after the call of recursion */
-        //Print("\n\n// ** Perturb the both vectors with degree %d with",nlev);
-        //idElements(G, "G");
-
+        // to dispense with taking initials and lifting/interreducing
+        // after the call of recursion.
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Perturb the both vectors with degree %d.",nlev);
+          //idElements(G, "G");
+        }
         Xngleich = 1;
         nlev +=1;
-
-        if (rParameter(currRing) != NULL)
-          DefRingPar(omtmp);
+        if(ivtarget->length() == nV)
+        {
+          if (rParameter(currRing) != NULL)
+            DefRingPar(omtmp);
+          else
+            rChangeCurrRing(VMrDefault(omtmp));
+        }
         else
-          rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung3
-
+        {
+          rChangeCurrRing(VMatrDefault(ivtarget));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
 
-        /* perturb the original target vector w.r.t. the current GB */
-        delete Xtau;
-        Xtau = NewVectorlp(Gt);
+        // perturb the original target vector w.r.t. the current GB
+        if(ivtarget->length() == nV)
+        {
+          delete Xtau;
+          Xtau = NewVectorlp(Gt);
+        }
+        else
+        {
+          delete Xtau;
+          Xtau = Mfpertvector(Gt,ivtarget);
+        }
 
         rChangeCurrRing(oRing);
-        G = idrMoveR(Gt, testring,currRing);
-
-        /* perturb the current vector w.r.t. the current GB */
+        G = idrMoveR(Gt,testring,currRing);
+
+        // perturb the current vector w.r.t. the current GB
         Mwlp = MivWeightOrderlp(omega);
+        if(ivtarget->length() > nV)
+        {
+          delete Mwlp;
+          Mwlp = MivMatrixOrderRefine(omega,ivtarget);
+        }
         Xsigma = Mfpertvector(G, Mwlp);
         delete Mwlp;
@@ -6568 +7109 @@
 
         next_vect = MkInterRedNextWeight(omega,omega2,G);
+        if(polylength > 0)
+        {
+          //there is a polynomial in Gomega with at least 3 monomials,
+          //low-dimensional facet of the cone
+          delete next_vect;
+          next_vect = MWalkRandomNextWeight(G,omega,omega2,weight_rad,1+nlev);
+          if(isNolVector(next_vect))
+          {
+            delete next_vect;
+            next_vect = MkInterRedNextWeight(omega,omega2,G);
+          }
+        }
         xtnw=xtnw+clock()-to;
-
-#ifdef PRINT_VECTORS
+      }
+//#ifdef PRINT_VECTORS
+      if(printout > 0)
+      {
         MivString(omega, omega2, next_vect);
-#endif
-      }
-
-
-    /* check whether the the computed vector is in the correct cone */
-    /* If no, the reduced GB of an omega-homogeneous ideal will be
+      }
+//#endif
+
+    /* check whether the the computed vector is in the correct cone
+       If no, the reduced GB of an omega-homogeneous ideal will be
        computed by Buchberger algorithm and stop this recursion step*/
     //if(test_w_in_ConeCC(G, next_vect) != 1) //e.g. Example s7, cyc6
@@ -6583 +7137 @@
     {
       delete next_vect;
-      if (rParameter(currRing) != NULL)
-      {
-        DefRingPar(omtmp);
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+        {
+          DefRingPar(omtmp);
+        }
+        else
+        {
+          rChangeCurrRing(VMrDefault(omtmp));
+        }
       }
       else
       {
-        rChangeCurrRing(VMrDefault1(omtmp)); // Aenderung4
+        rChangeCurrRing(VMatrDefault(ivtarget));
       }
 #ifdef TEST_OVERFLOW
       Gt = idrMoveR(G, oRing,currRing);
-      Gt = NULL; return(Gt);
-#endif
-
-      //Print("\n\n// apply BB's alg. in ring r = %s;", rString(currRing));
+      Gt = NULL;
+      return(Gt);
+#endif
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: applying Buchberger's algorithm in ring r = %s;",
+              rString(currRing));
+      }
       to=clock();
       Gt = idrMoveR(G, oRing,currRing);
@@ -6605 +7170 @@
       delete omega2;
       delete altomega;
-
-      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
-      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      if(printout > 0)
+      {
+        Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
       nnflow ++;
-
       Overflow_Error = FALSE;
       return (G1);
     }
-
-
-    /* If the perturbed target vector stays in the correct cone,
-       return the current GB,
-       otherwise, return the computed  GB by the Buchberger-algorithm.
-       Then we update the perturbed target vectors w.r.t. this GB. */
-
-    /* the computed vector is equal to the origin vector, since
-       t is not defined */
+    /*
+       If the perturbed target vector stays in the correct cone,
+       return the current Groebner basis.
+       Otherwise, return the Groebner basis computed with Buchberger's
+       algorithm.
+       Then we update the perturbed target vectors w.r.t. this GB.
+    */
     if (MivComp(next_vect, XivNull) == 1)
     {
-      if (rParameter(currRing) != NULL)
-        DefRingPar(omtmp);
+      // The computed vector is equal to the origin vector,
+      // because t is not defined
+      if(ivtarget->length() == nV)
+      {
+        if (rParameter(currRing) != NULL)
+          DefRingPar(omtmp);
+        else
+          rChangeCurrRing(VMrDefault(omtmp));
+      }
       else
-        rChangeCurrRing(VMrDefault1(omtmp)); //Aenderung5
-
+      {
+        rChangeCurrRing(VMatrDefault(ivtarget));
+      }
       testring = currRing;
       Gt = idrMoveR(G, oRing,currRing);
 
-      if(test_w_in_ConeCC(Gt, omega2) == 1) {
+      if(test_w_in_ConeCC(Gt, omega2) == 1)
+      {
         delete omega2;
         delete next_vect;
         delete altomega;
-        //Print("\n// Leaving the %d-th recursion with %d steps ",nlev, nwalks);
-        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
-
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+                nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         return (Gt);
       }
       else
-      {
-        //ivString(omega2, "tau'");
-        //Print("\n//  tau' doesn't stay in the correct cone!!");
-
+      { 
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: target weight doesn't stay in the correct cone.\n");
+        }
 #ifndef  MSTDCC_FRACTAL
-        //07.08.03
         //ivString(Xtau, "old Xtau");
-        intvec* Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
 #ifdef TEST_OVERFLOW
       if(Overflow_Error == TRUE)
@@ -6677 +7262 @@
 
       FRACTAL_MSTDCC:
-        //Print("\n//  apply BB-Alg in ring = %s;", rString(currRing));
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: apply Buchberge's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
         to=clock();
         G = MstdCC(Gt);
@@ -6685 +7274 @@
 
         // update the original target vector w.r.t. the current GB
-        if(MivSame(Xivinput, Xivlp) == 1)
-          if (rParameter(currRing) != NULL)
-            DefRingParlp();
+        if(ivtarget->length() == nV)
+        {
+          if(MivSame(Xivinput, Xivlp) == 1)
+            if (rParameter(currRing) != NULL)
+              DefRingParlp();
+            else
+              VMrDefaultlp();
           else
-            VMrDefaultlp();
+            if (rParameter(currRing) != NULL)
+              DefRingPar(Xivinput);
+            else
+              rChangeCurrRing(VMrDefault(Xivinput));
+        }
         else
-          if (rParameter(currRing) != NULL)
-            DefRingPar(Xivinput);
-          else
-            rChangeCurrRing(VMrDefault1(Xivinput)); //Aenderung6
-
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
         testring = currRing;
         Gt = idrMoveR(G, oRing,currRing);
@@ -6708 +7303 @@
         delete next_vect;
         delete altomega;
-        /*
-          Print("\n// Leaving the %d-th recursion with %d steps,", nlev,nwalks);
-          Print(" ** Overflow_Error? (%d)", Overflow_Error);
-        */
+        if(printout > 0)
+        {
+          Print("\n//** rec_r_fractal_call: Leaving the %d-th recursion with %d steps.\n",
+                nlev,nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
         if(Overflow_Error == TRUE)
           nnflow ++;
@@ -6727 +7324 @@
 
     to=clock();
-    /* Take the initial form of <G> w.r.t. omega */
+    // Take the initial form of <G> w.r.t. omega
     Gomega = MwalkInitialForm(G, omega);
     xtif=xtif+clock()-to;
-
+    //polylength = 1 if there is a polynomial in Gomega with at least 3 monomials and 0 otherwise
+    polylength = lengthpoly(Gomega);
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_r_fractal_call: Gomega");
+    }
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(omega) == 0)
@@ -6736 +7338 @@
     else
       hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
-#endif // BUCHBERGER_ALG
-
-    if (rParameter(currRing) != NULL)
-      DefRingPar(omega);
+#endif
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
     else
-      rChangeCurrRing(VMrDefault1(omega)); //Aenderung7
-
+    {
+      rChangeCurrRing(VMatrRefine(ivtarget,omega));
+    }
     Gomega1 = idrMoveR(Gomega, oRing,currRing);
 
-    /* Maximal recursion depth, to compute a red. GB */
-    /* Fractal walk with the alternative recursion */
-    /* alternative recursion */
-    // if(nlev == nV || lengthpoly(Gomega1) == 0)
+    // Maximal recursion depth, to compute a red. GB
+    // Fractal walk with the alternative recursion
+    // alternative recursion
     if(nlev == Xnlev || lengthpoly(Gomega1) == 0)
-      //if(nlev == nV) // blind recursion
-    {
-      /*
-      if(Xnlev != nV)
-      {
-        Print("\n// ** Xnlev = %d", Xnlev);
-        ivString(Xtau, "Xtau");
-      }
-      */
+    {
       to=clock();
 #ifdef  BUCHBERGER_ALG
@@ -6765 +7363 @@
       Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
       delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
       xtstd=xtstd+clock()-to;
     }
-    else {
+    else
+    {
       rChangeCurrRing(oRing);
       Gomega1 = idrMoveR(Gomega1, oRing,currRing);
-      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega);
-    }
-
-    //convert a Groebner basis from a ring to another ring,
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_r_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
     new_ring = currRing;
 
@@ -6782 +7384 @@
 
     to=clock();
-    /* Lifting process */
+    // Lifting process
     F = MLifttwoIdeal(Gomega2, Gresult1, G);
     xtlift=xtlift+clock()-to;
+
+    if(printout > 2)
+    {
+      idString(F,"//** rec_r_fractal_call: F");
+    }
+
     idDelete(&Gresult1);
     idDelete(&Gomega2);
@@ -6793 +7401 @@
 
     to=clock();
-    /* Interreduce G */
+    // Interreduce G
     G = kInterRedCC(F1, NULL);
     xtred=xtred+clock()-to;
@@ -6799 +7407 @@
   }
 }
-
-
 
 
@@ -6807 +7413 @@
  *                                                                             *
  * The main procedur Mfwalk calls the recursive Subroutine                     *
- * rec_fractal_call to compute the wanted Grï¿œbner basis.                       *
- * At the main procedur we compute the reduced Grï¿œbner basis w.r.t. a "fast"   *
+ * rec_fractal_call to compute the wanted Groebner basis.                      *
+ * At the main procedur we compute the reduced Groebner basis w.r.t. a "fast"  *
  * order, e.g. "dp" and a sequence of weight vectors which are row vectors     *
  * of a matrix. This matrix defines the given monomial order, e.g. "lp"        *
  *******************************************************************************/
-ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget)
+ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget,
+             int reduction, int printout)
 {
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
@@ -6848 +7461 @@
       intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
       intvec* Mdp;
-
-      if(MivSame(ivstart, iv_dp) != 1)
-        Mdp = MivWeightOrderdp(ivstart);
+      if(ivstart->length() == nV)
+      {
+        if(MivSame(ivstart, iv_dp) != 1)
+          Mdp = MivWeightOrderdp(ivstart);
+        else
+          Mdp = MivMatrixOrderdp(nV);
+      }
       else
-        Mdp = MivMatrixOrderdp(nV);
+      {
+        Mdp = ivstart;
+      }
 
       Xsigma = Mfpertvector(I, Mdp);
@@ -6869 +7488 @@
   Xivlp = Mivlp(nV);
 
-  if(MivComp(ivtarget, Xivlp)  != 1)
-  {
-    if (rParameter(currRing) != NULL)
-      DefRingPar(ivtarget);
+  if(ivtarget->length() == nV)
+  {
+    if(MivComp(ivtarget, Xivlp)  != 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(ivtarget);
+      else
+        rChangeCurrRing(VMrDefault(ivtarget));
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp = MivWeightOrderlp(ivtarget);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
     else
-      rChangeCurrRing(VMrDefault1(ivtarget)); //Aenderung1
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp = MivWeightOrderlp(ivtarget);
-    Xtau = Mfpertvector(I1, Mlp);
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingParlp();
+      else
+        VMrDefaultlp();
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp =  MivMatrixOrderlp(nV);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
   }
   else
   {
-    if (rParameter(currRing) != NULL)
-      DefRingParlp();
-    else
-      VMrDefaultlp();
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp =  MivMatrixOrderlp(nV);
+    rChangeCurrRing(VMatrDefault(ivtarget));
+    I1 = idrMoveR(I,oldRing,currRing);
+    Mlp =  ivtarget;
     Xtau = Mfpertvector(I1, Mlp);
   }
@@ -6899 +7528 @@
   id_Delete(&I, oldRing);
   ring tRing = currRing;
-
-  if (rParameter(currRing) != NULL)
-    DefRingPar(ivstart);
+  if(ivtarget->length() == nV)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivstart);
+    else
+      rChangeCurrRing(VMrDefault(ivstart));
+  }
   else
-    rChangeCurrRing(VMrDefault1(ivstart)); //Aenderung2
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
 
   I = idrMoveR(I1,tRing,currRing);
@@ -6914 +7549 @@
   ring helpRing = currRing;
 
-  J = rec_fractal_call(J, 1, ivtarget);
+  J = rec_fractal_call(J,1,ivtarget,printout);
 
   rChangeCurrRing(oldRing);
@@ -6920 +7555 @@
   idSkipZeroes(resF);
 
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete Xivlp;
   delete Xsigma;
@@ -6938 +7574 @@
 }
 
-ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,int weight_rad)
+/*******************************************************************************
+ * The implementation of the fractal walk algorithm with random element        *
+ *                                                                             *
+ * The main procedur Mfwalk calls the recursive Subroutine                     *
+ * rec_r_fractal_call to compute the wanted Groebner basis.                    *
+ * At the main procedure we compute the reduced Groebner basis w.r.t. a "fast" *
+ * order, e.g. "dp" and a sequence of weight vectors which are row vectors     *
+ * of a matrix. This matrix defines the given monomial order, e.g. "lp"        *
+ *******************************************************************************/
+ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,
+              int weight_rad, int reduction, int printout)
 {
+  BITSET save1 = si_opt_1; // save current options
+  if(reduction == 0)
+  {
+    si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
+    //si_opt_1 &= (~Sy_bit(OPT_REDTAIL)); // not tail reductions
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
@@ -6974 +7626 @@
       intvec* iv_dp = MivUnit(nV); // define (1,1,...,1)
       intvec* Mdp;
-
-      if(MivSame(ivstart, iv_dp) != 1)
-        Mdp = MivWeightOrderdp(ivstart);
+      if(ivstart->length() == nV)
+      {
+        if(MivSame(ivstart, iv_dp) != 1)
+          Mdp = MivWeightOrderdp(ivstart);
+        else
+          Mdp = MivMatrixOrderdp(nV);
+      }
       else
-        Mdp = MivMatrixOrderdp(nV);
+      {
+        Mdp = ivstart;
+      }
 
       Xsigma = Mfpertvector(I, Mdp);
@@ -6995 +7653 @@
   Xivlp = Mivlp(nV);
 
-  if(MivComp(ivtarget, Xivlp)  != 1)
-  {
-    if (rParameter(currRing) != NULL)
-      DefRingPar(ivtarget);
+  if(ivtarget->length() == nV)
+  {
+    if(MivComp(ivtarget, Xivlp)  != 1)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(ivtarget);
+      else
+        rChangeCurrRing(VMrDefault(ivtarget));
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp = MivWeightOrderlp(ivtarget);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
     else
-      rChangeCurrRing(VMrDefault1(ivtarget)); //Aenderung1
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp = MivWeightOrderlp(ivtarget);
-    Xtau = Mfpertvector(I1, Mlp);
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingParlp();
+      else
+        VMrDefaultlp();
+
+      I1 = idrMoveR(I, oldRing,currRing);
+      Mlp =  MivMatrixOrderlp(nV);
+      Xtau = Mfpertvector(I1, Mlp);
+    }
   }
   else
   {
-    if (rParameter(currRing) != NULL)
-      DefRingParlp();
-    else
-      VMrDefaultlp();
-
-    I1 = idrMoveR(I, oldRing,currRing);
-    Mlp =  MivMatrixOrderlp(nV);
+    rChangeCurrRing(VMatrDefault(ivtarget));
+    I1 = idrMoveR(I,oldRing,currRing);
+    Mlp =  ivtarget;
     Xtau = Mfpertvector(I1, Mlp);
   }
@@ -7025 +7693 @@
   id_Delete(&I, oldRing);
   ring tRing = currRing;
-
-  if (rParameter(currRing) != NULL)
-    DefRingPar(ivstart);
+  if(ivtarget->length() == nV)
+  {
+    if (rParameter(currRing) != NULL)
+      DefRingPar(ivstart);
+    else
+      rChangeCurrRing(VMrDefault(ivstart));
+  }
   else
-    rChangeCurrRing(VMrDefault1(ivstart)); //Aenderung2
+  {
+    rChangeCurrRing(VMatrDefault(ivstart));
+  }
 
   I = idrMoveR(I1,tRing,currRing);
@@ -7039 +7713 @@
   ideal resF;
   ring helpRing = currRing;
-//ideal G, int nlev, intvec* omtmp, int weight_rad)
-  J = rec_r_fractal_call(J, 1, ivtarget,weight_rad);
+
+  J = rec_r_fractal_call(J,1,ivtarget,weight_rad,printout);
 
   rChangeCurrRing(oldRing);
@@ -7046 +7720 @@
   idSkipZeroes(resF);
 
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete Xivlp;
   delete Xsigma;
@@ -7101 +7776 @@
   intvec* hilb_func;
 #endif
-  /* to avoid (1,0,...,0) as the target vector */
+  // to avoid (1,0,...,0) as the target vector
   intvec* last_omega = new intvec(nV);
   for(i=nV-1; i>0; i--)
@@ -7116 +7791 @@
 
   to=clock();
-  /* compute a red. GB w.r.t. the help ring */
+  // compute a red. GB w.r.t. the help ring
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) = "dp"
     G = MstdCC(G);
@@ -7125 +7800 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 4
+      rChangeCurrRing(VMrDefault(curr_weight));
     G = idrMoveR(G, XXRing,currRing);
     G = MstdCC(G);
@@ -7151 +7826 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 5
+      rChangeCurrRing(VMrDefault(curr_weight));
     to=clock();
     Gw = idrMoveR(G, exring,currRing);
@@ -7186 +7861 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 6
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     newRing = currRing;
@@ -7271 +7946 @@
           DefRingPar(target_tmp);
         else
-          rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 8
+          rChangeCurrRing(VMrDefault(target_tmp));
 
       lpRing = currRing;
@@ -7331 +8006 @@
           DefRingPar(target_tmp);
         else
-          rChangeCurrRing(VMrDefault(target_tmp)); //Aenderung 9
+          rChangeCurrRing(VMrDefault(target_tmp));
 
       lpRing = currRing;
@@ -7534 +8209 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 10
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     G = idrMoveR(G, XXRing,currRing);
@@ -7567 +8242 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 11
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     to=clock();
@@ -7610 +8285 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 12
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -7779 +8454 @@
         else
         {
-          rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 13
+          rChangeCurrRing(VMrDefault(target_tmp));
         }
       }
@@ -7852 +8527 @@
         else
         {
-          rChangeCurrRing(VMrDefault(target_tmp)); // Aenderung 14
+          rChangeCurrRing(VMrDefault(target_tmp));
         }
       }
@@ -8095 +8770 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 15
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -8237 +8912 @@
 
   //Print("\n// \"Mpwalk\" (1,%d) took %d steps and %.2f sec. Overflow_Error (%d)", tp_deg, nwalk, ((double) clock()-tinput)/1000000, nOverflow_Error);
-
+  Print("\n// Mprwalk took %d steps. Ring= %s;\n", nwalk, rString(currRing));
   return(result);
-}
-
-/*******************************************************
- * THE PERTURBATION WALK ALGORITHM WITH RANDOM ELEMENT *
- *******************************************************/
-ideal Mprwalk(ideal Go, intvec* curr_weight, intvec* target_weight, int weight_rad, int op_deg, int tp_deg, ring baseRing)
-{
-  BITSET save1 = si_opt_1; // save current options
-  si_opt_1 &= (~Sy_bit(OPT_REDSB)); // no reduced Groebner basis
-  Set_Error(FALSE);
-  Overflow_Error = FALSE;
-#ifdef TIME_TEST
-  clock_t tinput=0, tostd=0, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
-  xtif=0; xtstd=0; xtlift=0; xtred=0; xtnw=0;
-  tinput = clock();
-  clock_t tim;
-#endif
-  int i,nwalk,nV = baseRing->N;
-
-  ideal G, Gomega, M, F, Gomega1, Gomega2, M1;
-  ring newRing;
-  ring XXRing = baseRing;
-  intvec* exivlp = Mivlp(nV);
-  intvec* orig_target = target_weight;
-  intvec* pert_target_vector = target_weight;
-  intvec* ivNull = new intvec(nV);
-  intvec* tmp_weight = new intvec(nV);
-#ifdef CHECK_IDEAL_MWALK
-  poly p;
-#endif
-  for(i=0; i<nV; i++)
-  {
-    (*tmp_weight)[i] = (*curr_weight)[i];
-  }
-#ifndef BUCHBERGER_ALG
-  intvec* hilb_func;
-   // to avoid (1,0,...,0) as the target vector
-  intvec* last_omega = new intvec(nV);
-  for(i=0 i<nV; i++)
-  {
-    (*last_omega)[i] = 1;
-  }
-  (*last_omega)[0] = 10000;
-#endif
-  baseRing = currRing;
-  newRing = VMrDefault(curr_weight);
-  rChangeCurrRing(newRing);
-  G = idrMoveR(Go,baseRing,currRing);
-#ifdef TIME_TEST
-  to = clock();
-#endif
-  G = kStd(G,NULL,testHomog,NULL,NULL,0,0,NULL);
-  idSkipZeroes(G);
-#ifdef TIME_TEST
-  tostd = tostd + to - clock();
-#endif
-#ifdef CHECK_IDEAL_MWALK
-  idString(G,"G");
-#endif
-  if(op_deg >1)
-  {
-    if(MivComp(curr_weight,MivUnit(nV)) == 1) //ring order is "dp"
-    {
-      curr_weight = MPertVectors(G, MivMatrixOrderdp(nV), op_deg);
-    }
-    else //ring order is not "dp"
-    {
-      curr_weight = MPertVectors(G, MivMatrixOrder(curr_weight), op_deg);
-    }
-  }
-  baseRing = currRing;
-  if(tp_deg > 1 && tp_deg <= nV)
-  {
-    pert_target_vector = target_weight;
-  }
-#ifdef CHECK_IDEAL_MWALK
-  ivString(curr_weight, "new curr_weight");
-  ivString(target_weight, "new target_weight");
-#endif
-  nwalk = 0;
-  while(1)
-  {
-    nwalk ++;
-#ifdef TIME_TEST
-    to = clock();
-#endif
-    Gomega = MwalkInitialForm(G, curr_weight); // compute an initial form ideal of <G> w.r.t. "curr_vector"
-#ifdef TIME_TEST
-    tif = tif + clock()-to; //time for computing initial form ideal
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(Gomega,"Gomega");
-#endif
-#ifndef  BUCHBERGER_ALG
-    if(isNolVector(curr_weight) == 0)
-    {
-      hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
-    }   
-    else
-    {
-      hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
-    }
-#endif
-    if(nwalk == 1)
-    {
-      newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
-    }
-    else
-    {
-      newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
-    }
-    rChangeCurrRing(newRing);
-    Gomega1 = idrMoveR(Gomega, baseRing,currRing);
-    idDelete(&Gomega);
-    // compute a Groebner basis of <Gomega> w.r.t. "newRing"
-#ifdef TIME_TEST
-    to = clock();
-#endif
-#ifndef  BUCHBERGER_ALG
-    M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
-    delete hilb_func;
-#else
-    M = kStd(Gomega1,NULL,testHomog,NULL,NULL,0,0,NULL);
-#endif
-    idSkipZeroes(M);
-#ifdef TIME_TEST
-    tstd = tstd + clock() - to;
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(M, "M");
-#endif
-    //change the ring to baseRing
-    rChangeCurrRing(baseRing);
-    M1 =  idrMoveR(M, newRing,currRing);
-    idDelete(&M);
-    Gomega2 = idrMoveR(Gomega1, newRing,currRing);
-    idDelete(&Gomega1);
-    to = clock();
-    // compute a representation of the generators of submod (M) with respect to those of mod (Gomega), where Gomega is a reduced Groebner basis w.r.t. the current ring
-    F = MLifttwoIdeal(Gomega2, M1, G);
-    idSkipZeroes(F);
-#ifdef TIME_TEST
-    tlift = tlift + clock() - to;
-#endif
-#ifdef CHECK_IDEAL_MWALK
-    idString(F,"F");
-#endif
-    rChangeCurrRing(newRing); // change the ring to newRing
-    G = idrMoveR(F,baseRing,currRing);
-    idDelete(&F);
-    baseRing = currRing; // set baseRing equal to newRing
-#ifdef CHECK_IDEAL_MWALK
-    idString(G,"G");
-#endif
-#ifdef TIME_TEST
-    to = clock();
-#endif
-    intvec* next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, op_deg);
-#ifdef TIME_TEST
-    tnw = tnw + clock() - to;
-#endif
-#ifdef PRINT_VECTORS
-    MivString(curr_weight, target_weight, next_weight);
-#endif
-    if(Overflow_Error == TRUE)
-    {
-      PrintS("\n//**Mprwalk: OVERFLOW: The computed vector does not stay in cone, the result may be wrong.\n");
-      delete next_weight;
-      break;
-    }
-
-    if(test_w_in_ConeCC(G,target_weight) == 1 || MivComp(next_weight, ivNull) == 1)
-    {
-      delete next_weight;
-      break;
-    }
-    //update tmp_weight and curr_weight
-    for(i=nV-1; i>=0; i--)
-    {
-      (*tmp_weight)[i] = (*curr_weight)[i];
-      (*curr_weight)[i] = (*next_weight)[i];
-    }
-    delete next_weight;
-  } //end of while-loop
-  Print("\n// Mprwalk took %d steps. Ring= %s;\n", nwalk, rString(currRing));
-  idSkipZeroes(G);
-  si_opt_1 = save1; //set original options, e. g. option(RedSB)
-  baseRing = currRing;
-  rChangeCurrRing(XXRing);
-  ideal Res = idrMoveR(G,baseRing,currRing);
-  delete tmp_weight;
-  delete ivNull;
-  delete exivlp;
-#ifndef BUCHBERGER_ALG
-  delete last_omega;
-#endif
-#ifdef TIME_TEST
-  TimeString(tinput, tostd, tif, tstd, tlift, tred, tnw, nstep);
-#endif
-  return(Res);
 }
 
@@ -8517 +8992 @@
         else
         {
-          rChangeCurrRing(VMrDefault(cw_tmp)); // Aenderung 16
+          rChangeCurrRing(VMrDefault(cw_tmp));
         }
         G = idrMoveR(Go, XXRing,currRing);
@@ -8591 +9066 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung 17
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -8653 +9128 @@
       else
       {
-        rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 18
+        rChangeCurrRing(VMrDefault(target_weight));
       }
       F1 = idrMoveR(G, newRing,currRing);

Singular/walk.h

@@ -54 +54 @@
 // compute a Groebner basis of an ideal G w.r.t. lexicographic order 
 //ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M);
-ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M, ring baseRing);
+ideal Mwalk(ideal Go, intvec* orig_M, intvec* target_M, ring baseRing, int reduction, int printout);
 
 // random walk algorithm to compute a Groebner basis
-ideal Mrwalk(ideal Go, intvec* curr_weight, intvec* target_weight, int weight_rad, int pert_deg, ring baseRing);
+
+ideal Mrwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int pert_deg, int reduction, int printout);
 
 /* the perturbation walk algorithm */
 
-ideal Mpwalk(ideal Go, int op_deg, int tp_deg,intvec* curr_weight,intvec* target_weight, int nP);
+ideal Mpwalk(ideal Go, int op_deg, int tp_deg,intvec* curr_weight,intvec* target_weight, int nP, int reduction, int printout);
 
 /* the perturbation walk algorithm with random element */
-
-ideal Mprwalk(ideal Go, intvec* curr_weight, intvec* target_weight, int weight_rad, int op_deg, int tp_deg, ring baseRing);
+ideal Mprwalk(ideal Go, intvec* orig_M, intvec* target_M, int weight_rad, int op_deg, int tp_deg, int nP, int reduction, int printout);
 
 /* The fractal walk algorithm */
-ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget);
+ideal Mfwalk(ideal G, intvec* ivstart, intvec* ivtarget, int reduction, int printout);
 
 /* The fractal walk algorithm with random element */
-ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget,int weight_rad);
+ideal Mfrwalk(ideal G, intvec* ivstart, intvec* ivtarget, int weight_rad, int reduction, int printout);
 
 /* Implement Tran's idea */

Tst/Long/ok_l2.lst

@@ -1 +1 @@
 algemodstd_l
 bug_tr642
+bug_tr677
 king_3_colors_l
 modstd_l

Tst/Long/primdec_l.res.gz.uu

@@ -1 +1 @@
 begin 640 primdec_l.res.gz
-M'XL("+EN3U0``W!R:6UD96-?;"YR97,`[%W;CN0X<GWOKTCLTRR4*HC!NP?=
-M@+T&C`4,P_#NBSU8#/)6657N'JP[;\K\>I^@1(K*4EZJNK:F=R<QF$J1(H/!
-M$T%&,!@S^M.?__6/_S$:C<2GT;__\5]&OUNOUG>?'Z>_^_'#G]HW]&F$RI\?
-M?WE<__#['S_P[^C3I]%?OSY^F2]F/W^^^V6QNUNM)^O40WX:I6=UQW1_U[8^
-M(JVSAN9N]/7QE^7HZT=)527'/TS&T_%L/!\OQO?CY?AA_/3[\0]_&,__^ONN
-MO_TT>IPO)I]'CQ]3G;L;30J:%K-R7BS'J=K?C>YI^5!.4I6H[D:+^V4YZVH$
-M&BWIJ9QV5<3D0*VX+Y:EZ.KEW4A.YH6<S@N:S8OY?3%?EI.2IN6L7"8.A>IF
-M*/3=Z//C:@WDQ,<OC[_\\VKU;W_^GQ\>N_D(D^8C/GZ=S!]GD\^]]]U\Z>/B
-M_S:/_S70QGV*H]#'**3C<7QJ(UM._O`P^?K#XUATC:A*C=3'ELZ?_ONH#;3F
-MRV3]];$>??DX`XF?5XNOCXM5/A@1ZXKX\<-/XB__]`&2^!D/'P/,]X5H*N@O
-M'TM4%/</!2V?BD6LEZ@/4J/0'M(JYN6R>:?PCBMF35&C*$Q5"6Y?3)OG61%^
-MYDVI[6C^\K%3D`\8.^.*^S:LE<N,.8J,O1];,F-KF1BY+]\1&96S4'9HW+\;
-M"U&%L*$\0H,>!;,R+>=!<U"B7FM4@*<Y9'5/#PWQZ0R+^?ZI'?`>&@8MFT&2
-MX/FI"((&/T]-8[0EM&5!/S$Q3"+L#_RL6Y4-#;EVVO;AEV!ZQNH;@("BR(`&
-MB%$`YZ'$B*7"B*5ID"H7RX)U2K%.H0G&+(@IV4P'"P8P[#K\QN&-?(@3"3-@
-M1G.FJ&P';.>SN.>.'L*3#VVCZ0+<+)@E-$7[Y0.U\U@^/`5>GTJYI(=$H<5Q
-MP3RA+7A[*J:1C?9W`6H/)5H\!`E50(,)%>H^-`^H4,FP4#%;@#NS8!X7#634
-M-'D(<J&"8:*"<2(`P#R!)>!$Y0(=(4'#,`;Y"-9+]4215_!=`J.L'*%AB<C[
-M,*^&&1F8X9?5(BD+X\*JPP,SAMI['YB4@3T*/#4MZ3X^+,N62H"TF"XC.(PQ
-MZ!$F'&124L=/8C&B&[0!K24FJ)>Q6?E0RJ>T"&!*'@F+@'J+@(X7`;WE(J!L
-M$="Y14!OM@CHY"*@URX">N=%0.^V".BWM@@T.Q/4.1/Q=\BO..-:=`:,W\V+
-MUJY&V]6I7^OWI9<Z]IFF*M/:P6(2&*+OB:'(S3.8GCLZ@[[..^+TZW(4_:UC
-MH'(*T?5Y/U#><?3H[3T#@'H<+!L/+S*![99RY69KL>0U?&+H/KOF'+OV.;ON
-M/%@]1LN_Y;**NY'AW4@>'6WFR5&>=B<<R49ZAAT.HU#RD1O;R\:V7$0'6[,=
-M9?L83QL!I8?&6"\20<L&Y@&F!)LKFH)JV]Q%@QU*,'PS[,\%_H6H^&G&M&9M
-M8[93V,=A5V!_9_34UF(6"PFJO/)FP3;-8'@6+>,"4YO!Q#R5LX4J%PJ#+6"5
-M%Q+8J!DMN/U"@34>"6]0N6`KMY#]T];PL6:>T.D.#]/N<'!T,AH\ELQC[6DB
-M^=DFB(627*CSKCK1Y2<;ME+1.B7JT95JSC2+Z(Z4R0])H[-'TQL0HIS#&K((
-MV)0&8[E@)X!]HP?X3,'VEPK%IR1CMN-E,./MB!``&K'OXG+K^I#T@.U_VW89
-M+%`TNVEN01NR25"TU.RKQ?:4_,-<7>:+UKBG/LO`#\U9O:$'\Z>PA].B4`]I
-M_5A>/^JT->])9D`XS^1S2D0ODM()09V552LGQU->=*)ZE;2N%=CK9792;+W^
-MU",P#T),A+#O/+34CC?BOQ^IG5IA?V]B.[_:3CF!Y[R+>=]0SG)Q]$SBB_V6
-M%U`^Y93U[3CE_5H[VS?F;&D?ADQ\YMR8(^?&LGS*6:X-LV4NYF/7ISGRX>A4
-MSHY>\))8L.F>@8FR4]9@1^FEKLS\:O1.>'3S'G+/%V7NI23XGCDJ<=#<5TE`
-M'KLK$=$ACR6BFYR6"/!IOR7A?>RZ)+Q/>B\=\*]S8`:$=</S&_",GH#[-/KR
-MXX<O/XDQ1J,FGA6*?%R>3!?%!/O^=+XHYC"ODT6)$O%M2VC##OZT]>ZYS-'G
-M28B&<0F@3J8<$YI,8<.F;,@F<RY/\;>8@QV\X==LX::\@W+]!*\>RDF@P)[_
-MA*9/Q2180-`!\Z#Q!([X6($-?T+\`F_GX<SPY2<:!]7@!P[0808TQ78\A;@F
-M_+Q@P<W"^X;]AGEBYIOI!_8ILH\JR=S/&G8+U=3-`J>$"GX*'7CQ,[,*W?!W
-M*IG9Z8P?"7^GD"TF$MZ'.GX=WN+/C.<$*I*YGX2'L+WR@^3MAA]4,S')K#5<
-M2QZ4V56QGXK]5.RG0K_07(6>X<$TQB*J@?\T6B]6Z__\^OAE\G7_PU^_TIBO
-MDE(#67T:_>_CY\^CK^E^28KNBDW2\27B=+P:K\>;\7:\&]?C_?CP[!)1RN>7
-MB%+=C:;;8K5)]WU2HV97K+,:<S=:H6;;U5BTV1>KNJMQJ#D4ZZS&HQ=J]JE&
-M57>CS;[8=FV40,VAV&4UF-<6-?O$M<KN6)6Z=+&H]/F+164N7RPJ>_EB4;DK
-M+A:5OWRQJ*O+%XM:#%TL'M(A;I^.;W4ZNNW2>6V;SF.;_JETM2FFVT3DD(CL
-M$Y$Z$=DE(NO^N72(BUTBL$T$UHG`JG\F78.+W95<;',B.B<"%;Z6R"81F7[`
-MWVL!72<"JYR`S0&MB^E^@(LA/#8YH&Z0BWJ`P&8`4'#A,P+;NMB<Y^+$5&`7
-M,T0QEVMEV\T%8A&YCNX')K,=F$R?CUQ)=YC-$!_;B[/)M72-S>H\L$.S82JY
-MJG8:MDT4-A?YR/5TA^UOB(]+5.)&0/GU<$.LN1QN)MC<"S>0-=>ZC3(TU[J-
-M2)M;W$95FWO89O$T-Z_-:FPN4YO]H;WHW.P/\29RVCYBV-6N><2HT_:1Y=JP
-M)7@2[2//HGW$B-.&/X$!IPW;PG.#P!%5W*!YY-&V@1]B*PLV(Q(ROR-LD:`,
-M"<J0H`P)RI"@#`G*D*`,"<J0H`X)ZI"@#@GJD*`.">J0H`X)ZI"@#@GJD*`.
-M">J0H&=(J`L718?<:]_G'GN=.^J[W#??YD[Y9N@L\`943YW67T-ZG9-.ANTM
-MF!Z@?.JT?B7Y;4Y^E9-/MO"5C%^B?.J@?"7Y30^7:'+C$--O8/P2Y6CL7\GX
-M^B0NW\+T.:K1L3C+\"XGO3V-1T\#HX]QENG74XX.S3'C^U>0[VM@="B.&7\C
-MRM&)NEY%=CGY[6E<7J8B5U.-3ML+5"1Z=I'\M^CUZRDG1_&LCFQ[H$0O[I6<
-MOQ'EY)P><UZ?1N;TXHD^Y5G.WXAR<HK/:DO=0^:Z97]94UY'-3G@Y[&.#G&D
-MO\GIOU!+WHAR<OK/ZG</E2MWJLNZ_3JJZ9!QS/$NI[U]*YS?@"K[P</ZW+M+
-MVU-.O>XM]'J?TZ][%QR[?=<47O:.NB(\[9U,)7^L*.SA;W<=:7;SM[M.+.SK
-M;RE[SW*B#A'V^K<=??;\^UL4'P#ZVRV?`S;Y$(X/#EG9<SD#G0\AE"F[X'+V
-MGKC<R858,!U+Q*+)\"%>N[NLS"8U0X#X8)2Q1WPXVF;O/9=WF:0JKL@8E"',
-MDY7YF+;)>TBNR#2)6<QD)IG%;(:26:0,(FE#14:1F:1-5L%<=B"HZGB;57D8
-MJ:GA8UTV426YG+F`B@\$69G5?),QH=C.KS,"ELM9!\?E;)7S47.=+70PN<IT
-M37.,*1.L9@;S26KFD+)UQQQVD];IZ)MJ<H^RJ;'9,:2I<=F)JJGA(VHV<</G
-MU&Q>A@^KV3Q,.+%F[_F0O,K>*RYG]H.O^`:O"[N+/\JW%)EO-L=[9>_4V4W+
-MYINMR[=AS_8OGJ[U4.+3M:'7+.C9'!SI:B(GHDEY4*M.!#:)P#H16"4"73I0
-ML]7UPJ^OBM#U0EJ)P`N"8F:0@^VUTP@;:B_TVH&YNY)(LP>?"+T.260[,)7V
-M6.TO$+D8$.^%7O<#<SDODO8$)*[7T<T`(LWNUP^_OBH:+8:U]/QL,C["OMP/
-MO5Z[XGJ7';W0ZY"&#/&1R25LC'$C,!<RN+[_D_T;AMO>)SYXU0'B.CQZ&2/)
-M\+_%86V`\E5AMN_JK/9MX;4S>$2'ZBWB@@.43X79OO]HU8DPV_<;K7IQ>.U[
-MB7F_.,S6<R57.?F>!J9#W/7[]8LHOR+,=B7]=""]/LSV(LHGPVS?<3CBA''\
-MCD,^UUC'34[[6AG&>,A9Z_AZRB?#:U<N^%_A,N=4>.TU3L[[WE1>%V9[%BL]
-M"HT<Q[#T<0@KMYBAPA['%=QQ=,4?QQDX\M:/,X0K]G[R99T%KCCTMLG+JKF1
-M3^6CP!9'WE9YV39W]:GLF@O[5/;-K7T"JFKNZU-9-)?VJ<RBRN)L+*PL@,EQ
-MMVU>YER3O,SLY65F+R^[?CB*VD2!)+8V6R"5><EV['#0;5/W8V[3O*SZ01V.
-MN66!4@ZY]8)\(6AY%'#;]>-MJZS,`;=I7A;]H"8'VZ9Y6399#JG<CZMRK.U9
-MJ"TO,WAYV?5BH"I$L++`6=6+#H9`VSI[S<RM^W&V/&`U$&>;KK+F)L2,L_5C
-M0V`OJW`AI)M5^!!6[BI,"/KF%2$8N,XJ0M@WBXISF&U#F89PG&U%&<@<:`.-
-M;W&_+AP+1^UFT&'E\NW5Y\E--L^,WL2<Z&U,?-[%C.<Z)COO8\[R(:8AKV(:
-M\C;F&S=[3)MN7,<\XWW,'S[$%.!I3`%>Q13@=4P!WL04X&U,`-[%!.!I3`!>
-MQ03@34P`WL;TWSJF__*@.O;2L9>.8^DXEHZ]]#@9S2\_F=C3Q)XF]C1Q;B;.
-MS<2YV=C+QEXV]K*12QM[V7%RX;[\Y&)/%WNZV-.-58.!&R=+P(5V3!\EX;GG
-M.CS(9B@?>_HXIH^]1!6[X8E:!:AB1SRU/?$415^-D]U!*:C-NGFB:$I"*2I/
-MISV=^B3]$10G+"CR+2B*5%`:GZ)X1-(@(=/8,O$N$^\R]0UJU!C&4(K]DS()
-ME?H'=6IL9BA%WE7B7:7^2:V$3OUU&E^G\9-JB:!;C9F/Z\]=2$G7_EE*NJD^
-MQ33TZIH4=".>IZ`;.DY!-_(X!=VHXQ1THX]3T(TY3D$W]C@%W;CC%'3CCU/0
-M;76<@FZSQ'M+EU+0K3R?@F[5Y11TJR^GH%MS10JZM9=3T*V[G()N_2T%_9:"
-M?DM!_\VGH+OJEH+>(B%N*>@M$G1+0;^EH%]'^9:"?DM!OT#YEH)^2T&_I:!G
-MR)Q>/+<4]%L*^LMVJEL*>L?Q+04]U=Q2T&\IZ*%\2T%ORM]/"KJ3MQ3T6PKZ
-M+07]-Y^"[M0M!;TC?TM!/T?YEH*>\+BEH-]2T&\IZ*^B?$M!OZ6@G^/XEH)^
-M2T&_I:#?4M"3V&XIZ+<4]+_C%'2G;RGHMQ3T6PKZKY6"[LR%%'1GGZ6@.]<E
-M9SN?_J_HH_9_BSZ<A^ZKYWGH7MR-A-V;0OF]+OU>%4K4="@$[64AY9X*(?:%
-ME2E1W-/=2-%>\TM5$!KO"V&YBY'H(D2-YA;]//IU'U3V\FY$!M5*U8%ZX3N^
-MLJ\H^XM?4?87OJ+LK_B*LK_B*\K^BJ\HB^KR5Y1%=?DKRJ(:_(KRH?#6V@_)