Changeset 38301d in git

Timestamp:

Jul 11, 2015, 10:21:42 AM (8 years ago)

Author:

Stephan Oberfranz <oberfran@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

47362dcbb6b4fbb3b9d6cded63720e333b4c97b3

Parents:

d52203afadb18a3c05d4c08a2bc18bc327690cd9e9478bb30a6f3a2d77328b3805644a035ac3e934

Message:

update

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

Files:

• Singular/LIB/crypto.lib (modified) (2 diffs)
• Singular/LIB/gradedModules.lib (modified) (88 diffs)
• Singular/LIB/grwalk.lib (modified) (10 diffs)
• Singular/LIB/modwalk.lib (modified) (1 diff, 1 prop)
• Singular/LIB/nfmodstd.lib (modified) (1 diff)
• Singular/LIB/primdec.lib (modified) (9 diffs)
• Singular/LIB/rwalk.lib (modified) (11 diffs, 1 prop)
• Singular/LIB/surf.lib (modified) (4 diffs)
• Singular/LIB/swalk.lib (modified) (1 prop)
• Singular/Makefile.am (modified) (1 diff)
• Singular/dyn_modules/singmathic/singmathic.cc (modified) (1 diff)
• Singular/dyn_modules/syzextra/mod_main.cc (modified) (3 diffs)
• Singular/extra.cc (modified) (1 diff)
• Singular/maps_ip.cc (modified) (5 diffs)
• Singular/misc_ip.cc (modified) (2 diffs)
• Singular/omSingularConfig.h (deleted)
• Singular/test.cc (modified) (1 diff)
• Singular/walk.cc (modified) (142 diffs, 1 prop)
• Singular/walk.h (modified) (1 diff, 1 prop)
• Tst/New/grmodexamples.tst (modified) (2 diffs)
• Tst/Old/preimage.res.gz.uu (modified) (2 diffs)
• Tst/Short/bug_newstruct2.tst (modified) (1 diff)
• Tst/Short/bug_tr678_680.tst (modified) (1 diff)
• Tst/Short/bug_tr704.tst (modified) (1 diff)
• Tst/Short/bug_tr709.tst (modified) (1 diff)
• Tst/Short/bug_tr723.res.gz.uu (added)
• Tst/Short/bug_tr723.stat (added)
• Tst/Short/bug_tr723.tst (added)
• Tst/Short/bug_tr724.res.gz.uu (added)
• Tst/Short/bug_tr724.stat (added)
• Tst/Short/bug_tr724.tst (added)
• Tst/Short/elimlib_s.res.gz.uu (modified) (1 diff)
• Tst/Short/ok_s.lst (modified) (1 diff)
• configure.ac (modified) (1 diff)
• factory/NTLconvert.cc (modified) (1 diff)
• kernel/GBEngine/kstd2.cc (modified) (1 diff)
• kernel/GBEngine/syz0.cc (modified) (4 diffs)
• kernel/preimage.cc (modified) (1 diff)
• libpolys/coeffs/longrat.h (modified) (2 diffs)
• libpolys/coeffs/modulop.cc (modified) (1 diff)
• libpolys/coeffs/numbers.cc (modified) (1 diff)
• libpolys/coeffs/rintegers.cc (modified) (1 diff)
• libpolys/polys/ext_fields/transext.cc (modified) (29 diffs)
• libpolys/polys/monomials/p_polys.cc (modified) (18 diffs)
• libpolys/polys/monomials/ring.cc (modified) (4 diffs)
• libpolys/polys/monomials/ring.h (modified) (1 diff)
• libpolys/polys/polys0.cc (modified) (4 diffs)
• libpolys/polys/simpleideals.h (modified) (1 diff)
• omalloc/omDefaultConfig.h (modified) (1 diff)

Singular/LIB/crypto.lib

@@ -69 +69 @@
   merkle_hellman_transformation(list knapsack, int key, int mod1                generates a hard knapsack for the  Merkle-Hellman Kryptosystem for a given easy knapsack , a multiplicator key and a modulus mod1
   merkle_hellman_encryption(list knapsack, list message)                    encrypts a message with the Merkle-Hellman Kryptosystem, using a hard knapsack and a message encoded as binary list
-  merkle_hellman_decryption(list knapsack, int key, int mod1, int message)          decrypts a message with the multiplicative Merkle-Hellman Kryptosystem, using the hard knapsack, the key, the modulus mod1 and the message encoded as integer   
+  merkle_hellman_decryption(list knapsack, int key, int mod1, int message)          decrypts a message with the multiplicative Merkle-Hellman Kryptosystem, using the hard knapsack, the key, the modulus mod1 and the message encoded as integer
   super_increasing_knapsack(int ksize)                            Creates the smallest super-increasing knapsack of given size ksize
   h_increasing_knapsack(int ksize, int h)                            Creates the smallest h-increasing knapsack of given size ksize and h
@@ -1272 +1272 @@
    if((k mod 2)==0)
    {
-      resu=ellipticMult(N,a,b,P,k/2);
+      resu=ellipticMult(N,a,b,P,k div 2);
       return(ellipticAdd(N,a,b,resu,resu));
    }

Singular/LIB/gradedModules.lib

@@ -31 +31 @@
     grsum(M,N)      direct sum of two graded modules coker(M) + coker(N)
     grpower(M,p)    direct p-th power of graded module coker(M)
-    grtranspose(M)  un-ordered graded transpose of map M        
+    grtranspose(M)  un-ordered graded transpose of map M
     grgens(M)       try to compute submodule generators of coker(M)
     grpres(F)       presentation of submodule generated by columns of F
@@ -51 +51 @@
     mappingcone(M,N)   mapping cone?
     grlifting3(A,B)    RND! chain lifting? probably wrong one
-    mappingcone3(A,B)  mapping cone3? 
+    mappingcone3(A,B)  mapping cone3?
     grrange(M)         get the row-weightings
     grneg(A)           graded object given by -A
     matrixpres(a)      matrix presentation of direct sum of Omega^{a[i]}(i)
 ";
-    
+
 //    grisequal(A,B)  check whether A is exactly eqal to B? TODO: isomorphic!
 
@@ -86 +86 @@
 
   v = -v; // NOTE: due to Mathematical meanings of Singular data
-  
+
 
   int lst = v[1];
-  int cnt = 1; 
+  int cnt = 1;
 
   string p = R;
@@ -95 +95 @@
 
   int k, d;
-  for (k = 2; k <= n; k++ ) 
+  for (k = 2; k <= n; k++ )
   {
     d = v[k];
     if( d == lst ) { cnt = cnt + 1; }
-    else 
+    else
     {
       if (cnt > 1){ p = p + "^" + string(cnt); }
@@ -120 +120 @@
   def E = grtwist(2, 0);
   def v = grrange(E); // grdeg(E);
-  grsumstr("", v );  
+  grsumstr("", v );
 }
 
@@ -180 +180 @@
   {
     int n = size(N); ASSUME(0, n > 0);
-    
+
     string msg1 = "";
     if( size(R) >= 2 )
@@ -186 +186 @@
       msg1 = msg1 + "(let R:="+R+")";
       R = "R"; // !!!
-    }    
+    }
     msg1 = msg1 + ": " ;
 
-    
+
 
     list arr; arr[n] = list();
     int exact = (1==1);
-    
+
     int i = 1;
-    
+
     ASSUME(1, grtest(N[i]));
-    
+
     string dst = grsumstr(R, grrange(N[i]));
     string src = grsumstr(R, grdeg(N[i]));
-    
+
     arr[i] = list(dst,  src);
 
     i = i + 1;
-    
+
     while( i <= n )
     {
       ASSUME(1, grtest(N[i]));
-      
+
       dst = grsumstr(R, grrange(N[i]));
-      
+
       if( exact && (src != dst) )
       {
@@ -218 +218 @@
 
       src = grsumstr(R, grdeg(N[i]));
-      
+
       arr[i] = list(dst,  src);
 
@@ -236 +236 @@
         msg = msg + newline + arr[i][1] + " <-- "+o+"_" + string(i) + " --";
       };
-      
+
       msg =  msg + newline + arr[n][2];
-      msg = msg + ", given by maps: "; 
+      msg = msg + ", given by maps: ";
     } else
     {
 //      print(arr);
 
-      msg = msg + "-object collection";      
+      msg = msg + "-object collection";
       o = "o";
-      
+
 //      for( i = 1; i <= n; i++ )
 //      {
 //        msg = msg + newline + arr[i][1] + " <-- "+o+"_" + string(i) + " -- " + arr[i][2];
-//      };      
-      msg = msg + ", given by the following maps (named here as "+o+"_[1 .. "+string(n)+"]): "; 
+//      };
+      msg = msg + ", given by the following maps (named here as "+o+"_[1 .. "+string(n)+"]): ";
     }
 
@@ -257 +257 @@
 
     for( i = 1; i <= size(N); i++ )
-    { 
+    {
       print( o+"_" + string(i) + " :" );
-      grview( N[i] ); 
+      grview( N[i] );
     };
 
@@ -268 +268 @@
 
   ASSUME(1, grtest(N) );
-  
+
   msg = msg + " homomorphism";
   if( size(R) >= 2 )
@@ -280 +280 @@
   intvec gr = grrange(N); // grading weights?
   string dst = grsumstr(R, gr);
-  
+
   intvec G = grdeg(N);
   string src = grsumstr(R, G);
-  
+
   if( ncols(N) == 0 )
   {
     src = "0";
-  } 
+  }
 
   lst = msg;
 
-  if( (size(lst) + size(dst) + size(src) + 4) > 80 ) 
-  { 
+  if( (size(lst) + size(dst) + size(src) + 4) > 80 )
+  {
     if( (size(lst) + size(dst)) > 80 ) { msg = msg + newline; lst = ""; }
 
@@ -312 +312 @@
 //  lst = lst + ", given by ";
 
-  
+
   int nc = ncols(N); int nr = nrows(N);
 
@@ -323 +323 @@
   {
     ASSUME(0, nc > 0);
-    
+
     matrix M = module(N);
-    
+
     int r,c;
     int d = 1; // number of extra cols/rows for extra info around the central degree(N) block in D
@@ -361 +361 @@
       }
 
-    } else 
-    { 
+    } else
+    {
       msg = msg + "a matrix";
     }
 
-    print(msg + ", with degrees: " );    
-    draw(D, d); // print it nicely!    
+    print(msg + ", with degrees: " );
+    draw(D, d); // print it nicely!
   }
 }
@@ -462 +462 @@
 "
 {
-  ASSUME(1, grtest(M) ); 
-  
+  ASSUME(1, grtest(M) );
+
   if ( typeof(attrib(M, "degHomog")) == "intvec" )
   {
@@ -469 +469 @@
 
     if( size(t) == 0 ){ return (t); } // ZERO!
-    
+
     ASSUME(2, ncols(M) == size(t) );
     return (t);
@@ -629 +629 @@
   "Input degrees: "; grview(I);
 
-  def RR = grres(I, 0, 1); list L = RR; 
+  def RR = grres(I, 0, 1); list L = RR;
 
   " = Non-minimal betti numbers: "; print(betti(L, 0), "betti");
@@ -830 +830 @@
 
   ring r=32003,(x,y,z),dp;
-  
+
   grview( grtwists ( intvec(-4, 1, 6 )) );
 
@@ -843 +843 @@
 "
 {
-  ASSUME(0, a > 0);  
+  ASSUME(0, a > 0);
   def Z = grtwists( intvec(d:a) ); // will set the rank as well
 //  ASSUME(2, grisequal(Z, grpower( grshift(grzero(), d), a ) )); // optional check
@@ -931 +931 @@
 
   def SS = grobj(S, c, dc);
-  
+
   ASSUME(0, size( grrange(SS) ) == (size(a) + size(b)) );
   ASSUME(0, size( grdeg(SS) ) == (size(da) + size(db)) );
   ASSUME(0, ncols( SS ) == size( grdeg(SS) ) );
   ASSUME(0, nrows( SS ) == size( grrange(SS) ) );
-  
+
   return(SS);
 }
@@ -984 +984 @@
 {
   ASSUME(1, grtest(M) );
-           
-           
+
+
 
   intvec a = grrange(M);
@@ -993 +993 @@
   {
     "!! Warning: shifting '0 <- 0' leaves it as it unchanged!";
-    return (M);    
-  }
-  
+    return (M);
+  }
+
   a = a - intvec(d:size(a));
   t = t - intvec(d:size(t));
@@ -1056 +1056 @@
 {
   ASSUME(0, size(w) >= nrows(A) );
-  
+
   module M = module(A);
 
@@ -1063 +1063 @@
 
   intvec @ww = 0:0;
-  
+
   if( size(#) > 0 )
   {
     ASSUME(0, typeof(#[1]) == "intvec" );
-    
+
     @ww = intvec( #[1] );
 
@@ -1077 +1077 @@
       }
     }
-    
+
     ASSUME(0, size(@ww) == ncols(M) );
   }
@@ -1091 +1091 @@
         M = freemodule(0);
       }
-      
+
       attrib( M, "rank", size(w) );
       attrib( M, "isHomog", w );
-      
+
 //      ASSUME(0, /* PROBLEM WITH ZERO COLUMNS / THEIR DEGREES! */ (ncols(M) == 0) );
     }
   }
-  
+
 //  type(@ww);  type(M);
-  
+
   ASSUME(0, size(@ww) == ncols(M) ); // ?!
-  
+
   attrib(M, "degHomog", @ww);
 
@@ -1132 +1132 @@
   grview( grobj( freemodule(0), intvec(1,2,3) ) );
 
-  matrix z1[0][3]; grview( grobj( z1, 0:0, intvec(1,2,3) ) ); 
+  matrix z1[0][3]; grview( grobj( z1, 0:0, intvec(1,2,3) ) );
   grview( grobj( freemodule(0), 0:0, intvec(1,2,3) ) );
 
   matrix z0[0][0]; grview( grobj( z0, 0:0 ) );
   grview( grobj( freemodule(0), 0:0 ) );
-  
-  
+
+
 
 }
@@ -1145 +1145 @@
 "USAGE:  grtest(M[,b]), anyting M, optionally int b
 RETURN:  1 if M is a valid graded object, 0 otherwise
-PURPOSE: validate a graded object. Print an invalid object message if b is not given 
+PURPOSE: validate a graded object. Print an invalid object message if b is not given
 NOTE: M should be an ideal or module or matrix, with weighting attribute
    'isHomog' and optionally total graded degrees attribute 'degHomog'.
@@ -1169 +1169 @@
   if ( nrows(N) != size(gr) )
   {
-    if(b) { "   ? grtest: Input has wrong number of rows!"; };    
+    if(b) { "   ? grtest: Input has wrong number of rows!"; };
     return (0);
   };
@@ -1177 +1177 @@
     return(1);
   }
-  
+
 //  if( attrib(N, "rank") != size(gr) ){ return (0); } // wrong rank :(
 
@@ -1189 +1189 @@
       return (1);
     }
-    
+
     if ( ncols(N) != size(T) )
     {
-      if(b) { "   ? grtest: Input has wrong number of cols!"; };    
+      if(b) { "   ? grtest: Input has wrong number of cols!"; };
       return (0);
     };
-    
+
     int k = nvars(basering) + 1; // index of mod. column in the leadexp
 
@@ -1259 +1259 @@
 {
   ASSUME(0, d >= 0 );
-  
+
   if( d == 0 ) { return (A); }
-  
+
   if( ncols(A) == 0 )
   {
     matrix B[nrows(A) + d][0];
-    return (B);    
-  }
-  
+    return (B);
+  }
+
   module T; T[d] = 0;
   T = T, module(transpose(A));
@@ -1281 +1281 @@
   matrix m[0][2];
   type( align(m, 3) );
-}  
+}
 
 
@@ -1302 +1302 @@
   module A = grobj( module([x+y, x, 0, 0], [0, x+y, y, 0]), intvec(0,0,0,1) );
   grview(A);
-  
+
   module B = grgroebner(A);
   grview(B);
@@ -1324 +1324 @@
   ring r=32003,(x,y,z),dp;
 
-  module A = grgroebner( grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ) ); 
+  module A = grgroebner( grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ) );
   grview(A);
-  
+
   grview(grsyz(A));
-  
-  module X = grgroebner( grobj( module([x]), intvec(2) ) ); 
+
+  module X = grgroebner( grobj( module([x]), intvec(2) ) );
   grview(X);
 
   // syzygy module should be zero!
   grview(grsyz(X));
-  
-  
+
+
 }
 
@@ -1351 +1351 @@
   intvec a = grdeg(A);
   intvec b = grrange(B);
-  
+
   ASSUME(0, (size(a) == size(b)) && (a == b));  // == for intvec :(
 
@@ -1361 +1361 @@
   ring r=32003,(x,y,z),dp;
 
-  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ); 
+  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) );
   grview(A);
-  
+
   A = grgroebner(A);
   grview(A);
-  
+
   module B = grsyz(A);
   grview(B);
   print(B);
-  
+
   module D = grprod( A, B );
   grview(D);
@@ -1384 +1384 @@
 "USAGE:  grres(M, l[, b]), graded object M, int l, int b
 RETURN:  graded resolution = list of graded objects
-PURPOSE: compute graded resolution of M (of length l) and minimise it if b was given                             
+PURPOSE: compute graded resolution of M (of length l) and minimise it if b was given
 EXAMPLE: example grres; shows an example
 "
@@ -1392 +1392 @@
 
   intvec v = grrange(A);
-  
+
   int b = (size(#) > 0);
   if(b) { list r = res(A, l, #[1]); } else { list r = res(A, l); }
 
   l = size(r);
-  
+
   int i;
-  
+
   for ( i = 1; i <= l; i++ )
   {
@@ -1411 +1411 @@
     r[i] = grobj(r[i], v); v = grdeg(r[i]);
   }
-  
+
   i = i-1;
 
@@ -1421 +1421 @@
   ring r=32003,(x,y,z),dp;
 
-  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ); 
+  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) );
   grview(A);
-  
+
   module B = grgroebner(A);
   grview(B);
@@ -1438 +1438 @@
 RETURN:  graded object
 PURPOSE: graded transpose of M
-NOTE:    no reordering is performend by this procedure   
+NOTE:    no reordering is performend by this procedure
 EXAMPLE: example grtranspose; shows an example
 "
@@ -1457 +1457 @@
 
   module K = grsyz( L ); grview(K);
-  
+
 
   // Corner cases: 0 <- 0!
@@ -1463 +1463 @@
   grview( grtranspose( Z ) );
 
-  
+
   // Corner cases: * <- 0
   matrix M1[3][0];
-  
+
   module Z1 = grobj( M1, intvec(-1, 0, 1) ); grview(Z1);
   grview( grtranspose( Z1 ) );
-  
-  
+
+
   // Corner cases: 0 <- *
   matrix M2[0][3];
@@ -1476 +1476 @@
   module Z2 = grobj( M2, 0:0, intvec(-1, 0, 1) ); grview(Z2);
   grview( grtranspose( Z2 ) );
-  
+
 }
 
@@ -1482 +1482 @@
 proc grgens(def M)
 "USAGE:   grgens(M), graded object M (map)
-RETURN:  graded object  
+RETURN:  graded object
 PURPOSE: try compute graded generators of coker(M) and return them as columns
          of a graded map.
@@ -1492 +1492 @@
 
   module N = grtranspose( grsyz( grtranspose(M) ) );
-  
+
 //  ASSUME(3, grisequal( grgroebner(M), grgroebner( grpres( N ) ) ) ); // FIXME: not always true!?
-  
+
   return ( N );
 }
@@ -1505 +1505 @@
 
   module N = grgens(M);
-  
+
   grview( N ); print(N); // fine == M
 
 
-  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) ); 
+  module A = grobj( module([x+y, x, 0, 3], [0, x+y, y, 2], [y, y, z, 1]), intvec(0,0,0,1) );
 
   A = grgroebner(A); grview(A);
@@ -1518 +1518 @@
 
   grview( grgens( grzero() ) );
-  
+
 }
 
@@ -1534 +1534 @@
 
 //  ASSUME(3, grisequal( M, grgens( N ) ) );
-  
+
   return ( N );
 }
@@ -1545 +1545 @@
   grview(A);
 
-  "graded transpose: "; def B = grtranspose(A); grview( B ); print(B); 
+  "graded transpose: "; def B = grtranspose(A); grview( B ); print(B);
 
   "... syzygy: "; def C = grsyz(B); grview(C);
@@ -1553 +1553 @@
   "... and back to presentation: "; def E = grsyz( D ); grview(E); print(E);
 
-  def F = grgens( E ); grview(F); print(F); 
+  def F = grgens( E ); grview(F); print(F);
   def G = grpres( F ); grview(G); print(G);
 
 
   def M = grtwists( intvec(-2, 0, 4, 4) ); grview(M);
-  
+
   def N = grgens(M); grview( N ); print(N);
-  
-  def L = grpres( N ); grview( L ); print(L);  
+
+  def L = grpres( N ); grview( L ); print(L);
 }
 
@@ -1652 +1652 @@
   module N;
 
-  if(i>n) 
+  if(i>n)
     { // no middle part
       if(a[1]>0)
@@ -1659 +1659 @@
 
           if(a[n+1]>0)
-            { N=grsum(N,grtwist(a[n+1],-1));}        
-        }  
+            { N=grsum(N,grtwist(a[n+1],-1));}
+        }
       else
         { N=grtwist(a[n+1],-1);}
-      
-      return (N); // grorder(N)); 
+
+      return (N); // grorder(N));
     }
-  else // i <= n: middle part is present, a_i != 0 
+  else // i <= n: middle part is present, a_i != 0
     { // a = a1  ... |  i:2, a_2 ..... i: n, a_n | .... i: n+1a_(n+1)
       j = i - 1;
@@ -1697 +1697 @@
 
 
-      return ((N)); //      return (grorder(N)); 
+      return ((N)); //      return (grorder(N));
     }
 }
@@ -1704 +1704 @@
   ring r = 32003,(x(0..4)),dp;
 
-  def N1 = KeneshlouMatrixPresentation(intvec(2,0,0,0,0)); 
+  def N1 = KeneshlouMatrixPresentation(intvec(2,0,0,0,0));
   grview(N1);
 
@@ -1738 +1738 @@
   ASSUME(1, grtest(B));
   ASSUME(0, grrange(A)==grrange(B));
- 
+
   intvec v = grrange(A);
   intvec w=grdeg(A),grdeg(B);
@@ -1746 +1746 @@
 { "EXAMPLE:"; echo = 2;
   ring r;
-  
+
   module R=grobj(module([x,y,z]),intvec(0:3));
   grview(R);
@@ -1771 +1771 @@
 //  matrix U;
   matrix L =lift(A,B/*,U*/);  //  module(B*U) = module(matrix(A)*L)
-  
+
   return(grobj(L, grdeg(A), grdeg(B)));
 }
@@ -1782 +1782 @@
 
 
-  module D=grobj(module([y,0,z],[x2+y2,z,0]),intvec(0,1,0)); 
+  module D=grobj(module([y,0,z],[x2+y2,z,0]),intvec(0,1,0));
   grview(D);
 
@@ -1788 +1788 @@
   grview(G);
 
-  ASSUME(0, grisequal( grprod(D, G), P) );  
+  ASSUME(0, grisequal( grprod(D, G), P) );
 }
 
@@ -1807 +1807 @@
 
   module Z = grobj(freemodule(0),intvec(0:0),intvec(0:0));
-  
+
   grrange(Z);
   grdeg(Z);
-  
+
   grview(Z);
 
@@ -1838 +1838 @@
        grtranspose( grprod( N,  alpha1 ) ) )
        ) ); // alpha0!
-    
+
 }
 example
@@ -1899 +1899 @@
 
   ASSUME(0, t >= 2);
-  
+
   list P;
 
   "t: ", t;
-  
+
   P[1]= grrndmap( rM[1], rN[1] ); // alpha1
 
-  if(t==2){return(P[1]);}  
-    
+  if(t==2){return(P[1]);}
+
   for(k=2; k<=t; k++)
   {
-    P[k] = grlift( grprod(P[k-1],rM[k]), rN[k] ); 
-     grview(P[k]);  
-    
-  }
-      
+    P[k] = grlift( grprod(P[k-1],rM[k]), rN[k] );
+     grview(P[k]);
+
+  }
+
   return(P);
-    
+
 }
 example
@@ -1923 +1923 @@
   ring r=32003,(x,y,z),dp;
 
-  module P=grobj(module([xy,0,xz]),intvec(0,1,0)); 
+  module P=grobj(module([xy,0,xz]),intvec(0,1,0));
   grview(P);
 
-  module D=grobj(module([y,0,z],[x2+y2,z,0]),intvec(0,1,0)); 
+  module D=grobj(module([y,0,z],[x2+y2,z,0]),intvec(0,1,0));
   grview(D);
 
@@ -1937 +1937 @@
   module D=grobj(module([y,0,z],[x2+y2,z,0], [z3, xy, xy2]),intvec(0,1,0));
   D = grgroebner(D);
-  grview( grres(D, 0)); 
+  grview( grres(D, 0));
 
   def G=grlifting(D, D);
@@ -1951 +1951 @@
   def M = KeneshlouMatrixPresentation(intvec(0,0,1,0));
   grview( grres(M, 0) );
-  
+
 //   module N = grshift(kos[3], 1); // psi, Syz_2(K(1))
   def N = KeneshlouMatrixPresentation(intvec(0,1,0,0));
@@ -1966 +1966 @@
 proc mappingcone(M,N)
 "USAGE: mappingcone(M,N), M,N graded objects
-RETURN: chain complex (as a list) 
+RETURN: chain complex (as a list)
 PURPOSE: construct a free resolution of the cokernel of a random map between Img(M), and Img(N).
 EXAMPLE: example mappingcone; shows an example
@@ -2026 +2026 @@
 
 // correct
-proc grrndmap(def S, def D, list #) 
+proc grrndmap(def S, def D, list #)
 "USAGE: grrndmap(S,D), graded objects S and D
 RETURN: graded object
@@ -2092 +2092 @@
 // 0<---M<----F0<----F1<----F2<----F3<----
 //              |p1   |p2
-// 
+//
 // 0<---N<----G0<----G1<----G2<----G3<----
 //                B(g1)      g2     g3
-// 
+//
 proc grlifting2(A,B)
 "USAGE: grlifting2(A,B), graded objects A and B (matrices defining maps)
-RETURN: map of chain complexes (as a list) 
+RETURN: map of chain complexes (as a list)
 PURPOSE: construct a map of chain complexes between free resolution of
 M=coker(A) and N=coker(B).
@@ -2127 +2127 @@
   P[1]=grrndmap2(A,B);
 
-  // A(or B)=0 
+  // A(or B)=0
   if(t==1){return(P[1])};
- 
+
   for(k=2;k<=t;k++)
   {
@@ -2161 +2161 @@
 def T=grlifting2(DD,PP); T;
 
-// def Z=grlifting2(P,D); Z; // WRONG!!!  
-             
+// def Z=grlifting2(P,D); Z; // WRONG!!!
+
 }
 
@@ -2171 +2171 @@
 proc mappingcone2(A,B)
 "USAGE: mappingcone2(A,B), graded objects A and B (matrices defining maps)
-RETURN: chain complex (as a list) 
+RETURN: chain complex (as a list)
 PURPOSE: construct the free resolution of a cokernel of a random map between M=coker(A), and N=coker(B)
 EXAMPLE: example mappingcone2;
@@ -2234 +2234 @@
 */
 
-proc grlifting3(A,B) 
+proc grlifting3(A,B)
 "TODO: grlifting4 was newer and had more documentation than this proc, but was removed... Please verify and update!
 "
@@ -2247 +2247 @@
   list rN = grres(B,0,1);
   print( betti(rN), "betti");
-  
+
   int i,j,k;
 
@@ -2260 +2260 @@
   }
   int t=min(i,j);
-  
+
   list P;
 
   "t: ", t;
 //  grview(rM[t]);  grview(rN[t]);
-  
+
   P[t]= grrndmap2(rM[t],rN[t]);
   grview(P[t]);
@@ -2312 +2312 @@
 //def I=KeneshlouMatrixPresentation(intvec(2,3,0,6,2));
 //def J=KeneshlouMatrixPresentation(intvec(4,0,1,2,1));
-//def N=grlifting3(I,J); grview(N); 
+//def N=grlifting3(I,J); grview(N);
 }
 
@@ -2318 +2318 @@
 "USAGE: grneg(A), graded object A
 RETURN: graded object
-PURPOSE: graded map defined by -A 
+PURPOSE: graded map defined by -A
 EXAMPLE: example grneg; shows an example
 "
@@ -2341 +2341 @@
 proc mappingcone3(A,B)
 "USAGE: mappingcone3(A,B), graded objects A and B (matrices defining maps)
-RETURN: chain complex (as a list) 
+RETURN: chain complex (as a list)
 PURPOSE: construct a free resolution of the cokernel of a random map between M=coker(A), and N=coker(B)
 EXAMPLE: example mappingcone3; shows an example
@@ -2376 +2376 @@
 
     T[i]=grtranspose(D);
-    
+
     kill A, B, C, D, v, w, r, s, zero;
   }
@@ -2394 +2394 @@
 def F=grlifting3(A,T); grview(F);
 
-// BUG in the proc  
+// BUG in the proc
 def G=mappingcone3(A,T); grview(G);
 
@@ -2403 +2403 @@
 ideal P=groebner(flatten(U[2]));
 resolution L=mres(P,0);
-print(betti(L),"betti");    
+print(betti(L),"betti");
 */
 
@@ -2421 +2421 @@
 def I=KeneshlouMatrixPresentation(intvec(2,3,0,6,2));
 def J=KeneshlouMatrixPresentation(intvec(4,0,1,2,1));
-// def N=grlifting3(I,J); 
+// def N=grlifting3(I,J);
 // 2nd module does not lie in the first:
 // def NN=mappingcone3(I,J); // ????????
@@ -2458 +2458 @@
   module N;
 
-  if(i>n) 
+  if(i>n)
     { // no middle part
       if(a[1]>0)
@@ -2465 +2465 @@
 
           if(a[n+1]>0)
-            { N=grsum(N,grtwist(a[n+1],0));}         
-        }  
+            { N=grsum(N,grtwist(a[n+1],0));}
+        }
       else
         { N=grtwist(a[n+1],0);}
-      
-      return (N); // grorder(N)); 
+
+      return (N); // grorder(N));
     }
 
-else // i <= n: middle part is present, a_i != 0 
+else // i <= n: middle part is present, a_i != 0
     { // a = a1  ... |  i:2, a_2 ..... i: n, a_n | .... i: n+1a_(n+1)
       module I = maxideal(1);
@@ -2505 +2505 @@
 
 
-      return ((N)); //      return (grorder(N)); 
+      return ((N)); //      return (grorder(N));
     }
 }
@@ -2518 +2518 @@
 grview(S);
 
-def N1 = matrixpres(intvec(2,0,0,0,0)); 
+def N1 = matrixpres(intvec(2,0,0,0,0));
 grview(N1);
 

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
@@ -274 +274 @@
    string ord_str =   OSCTW[2];
    intvec curr_weight   =   OSCTW[3]; /* original weight vector */
-   intvec target_weight =   OSCTW[4]; /* terget weight vector */
+   intvec target_weight =   OSCTW[4]; /* target weight vector */
    kill OSCTW;
    option(redSB);
@@ -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;
@@ -299 +299 @@
   //** compute a Groebner basis of I w.r.t. lp.
   ring r = 32003,(z,y,x), lp;
-  ideal I = y3+xyz+y2z+xz3, 3+xy+x2y+y2z;
-  gwalk(I);
+  ideal I = zy2+yx2+yx+3,
+            z3x+y3+zyx-yx2-yx-3,
+            z2yx3-y5+z2yx2+y3x2+y2x3+y3x+y2x2+3z2x+3y2+3yx,
+            zyx5+y6-y4x2-y3x3+2zyx4-y4x-y3x2+zyx3-3z2yx+3zx3-3y3-3y2x+3zx2,
+            yx7-y7+y5x2+y4x3+3yx6+y5x+y4x2+3yx5-6zyx3+yx4+3x5+3y4+3y3x-6zyx2+6x4+3x3-9zx;
+  gwalk(I,0,1);
 }
 
@@ -346 +350 @@
 }
 
-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 +376 @@
 
    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 +391 @@
     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 +443 @@
 }
 
-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 +483 @@
   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;
-  //kill Go;
+  //kill Go; //unused
 
   keepring basering;
@@ -492 +498 @@
     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/modwalk.lib

@@ -16 +16 @@
 
 PROCEDURES:
-modWalk(ideal,int,int[,int,int,int,int]);        standard basis conversion of I using modular methods (chinese remainder)
+
+modWalk(I,#);                   standard basis conversion of I by Groebner Walk using modular methods
+modrWalk(I,radius,pertdeg,#);   standard basis conversion of I by Random Walk using modular methods
+modfWalk(I,#);                  standard basis conversion of I by Fractal Walk using modular methods
+modfrWalk(I,radius,#);          standard basis conversion of I by Random Fractal Walk using modular methods
 ";
 
-LIB "poly.lib";
-LIB "ring.lib";
-LIB "parallel.lib";
 LIB "rwalk.lib";
 LIB "grwalk.lib";
-LIB "modstd.lib";
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-static proc modpWalk(def II, int p, int variant, list #)
-"USAGE:  modpWalk(I,p,#); I ideal, p integer, variant integer
-ASSUME:  If size(#) > 0, then
-           #[1] is an intvec describing the current weight vector
-           #[2] is an intvec describing the target weight vector
-RETURN:  ideal - a standard basis of I mod p, integer - p
-NOTE:    The procedure computes a standard basis of the ideal I modulo p and
-         fetches the result to the basering.
-EXAMPLE: example modpWalk; shows an example
-"
-{
-  option(redSB);
-  int k,nvar@r;
-  def R0 = basering;
-  string ordstr_R0 = ordstr(R0);
-  list rl = ringlist(R0);
-  int sizerl = size(rl);
-  int neg = 1 - attrib(R0,"global");
-  if(typeof(II) == "ideal")
-  {
-    ideal I = II;
+LIB "modular.lib";
+
+proc modWalk(ideal I, list #)
+"USAGE:   modWalk(I, [, v, w]); I ideal, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("gwalk", list(I,reduction,printout,#));
+    }
+    else {
+        I = modular("gwalk", list(I,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
+    ideal J = modWalk(I);
+    J;
+}
+
+proc modrWalk(ideal I, int radius, int pertdeg, list #)
+"USAGE:   modrWalk(I, radius, pertdeg[, v, w]);
+          I ideal, radius int, pertdeg int, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modrWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("rwalk", list(I,radius,pertdeg,reduction,printout,#));
+    }
+    else {
+        I = modular("rwalk", list(I,radius,pertdeg,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
     int radius = 2;
-    int pert_deg = 2;
-  }
-  if(typeof(II) == "list" && typeof(II[1]) == "ideal")
-  {
-    ideal I = II[1];
-    if(size(II) == 2)
-    {
-      int radius = II[2];
-      int pert_deg = 2;
-    }
-    if(size(II) == 3)
-    {
-      int radius = II[2];
-      int pert_deg = II[3];
-    }
-  }
-  rl[1] = p;
-  int h = homog(I);
-  def @r = ring(rl);
-  setring @r;
-  ideal i = fetch(R0,I);
-  string order;
-  if(system("nblocks") <= 2)
-  {
-    if(find(ordstr_R0, "M") + find(ordstr_R0, "lp") + find(ordstr_R0, "rp") <= 0)
-    {
-      order = "simple";
-    }
-  }
-
-//-------------------------  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);
-    }
-  }
-  if(variant == 2)
-  {
-    if(size(#) == 2)
-    {
-      i = gwalk(i,#);
-    }
-    else
-    {
-      i = gwalk(i);
-    }
-  }
-  if(variant == 3)
-  {
-    if(size(#) == 2)
-    {
-      i = frandwalk(i,radius,#);
-    }
-    else
-    {
-      i = frandwalk(i,radius);
-    }
-  }
-  if(variant == 4)
-  {
-    if(size(#) == 2)
-    {
-      i=fwalk(i,#);
-    }
-    else
-    {
-      i=fwalk(i);
-    }
-  }
-  if(variant == 5)
-  {
-    if(size(#) == 2)
-    {
-     i=prwalk(i,radius,pert_deg,pert_deg,#);
-    }
-    else
-    {
-      i=prwalk(i,radius,pert_deg,pert_deg);
-    }
-  }
-  if(variant == 6)
-  {
-    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;
-      }
-    }
-  }
-  setring R0;
-  return(list(fetch(@r,i),p));
-}
-example
-{
-  "EXAMPLE:"; echo = 2;
-  option(redSB);
-
-  int p = 181;
-  intvec a = 2,1,3,4;
-  intvec b = 1,9,1,1;
-  ring ra = 0,x(1..4),(a(a),lp);
-  ideal I = std(cyclic(4));
-  ring rb = 0,x(1..4),(a(b),lp);
-  ideal I = imap(ra,I);
-  modpWalk(I,p,1,a,b);
-  std(I);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-proc modWalk(def II, int variant, list #)
-"USAGE:  modWalk(II); II ideal or list(ideal,int)
-ASSUME:  If variant =
-@*       - 1 the Random Walk algorithm with radius II[2] is applied
-           to II[1] if II = list(ideal, int). It is applied to II with radius 2
-           if II is an ideal.
-@*       - 2, the Groebner Walk algorithm is applied to II[1] or to II, respectively.
-@*       - 3, the Fractal Walk algorithm with random element is applied to II[1] or II,
-           respectively.
-@*       - 4, the Fractal Walk algorithm is applied to II[1] or II, respectively.
-@*       - 5, the Perturbation Walk algorithm with random element is applied to II[1]
-           or II, respectively, with radius II[3] and perturbation degree II[2].
-@*       - 6, the Perturbation Walk algorithm is applied to II[1] or II, respectively,
-           with perturbation degree II[3].
-         If size(#) > 0, then # contains either 1, 2 or 4 integers such that
-@*       - #[1] is the number of available processors for the computation,
-@*       - #[2] is an optional parameter for the exactness of the computation,
-                if #[2] = 1, the procedure computes a standard basis for sure,
-@*       - #[3] is the number of primes until the first lifting,
-@*       - #[4] is the constant number of primes between two liftings until
-           the computation stops.
-RETURN:  a standard basis of I if no warning appears.
-NOTE:    The procedure converts a standard basis of I (over the rational
-         numbers) from the ordering \"a(v),lp\", "dp\" or \"Dp\" to the ordering
-         \"(a(w),lp\" or \"a(1,0,...,0),lp\" by using modular methods.
-         By default the procedure computes a standard basis of I for sure, but
-         if the optional parameter #[2] = 0, it computes a standard basis of I
-         with high probability.
-EXAMPLE: example modWalk; shows an example
-"
-{
-  int TT = timer;
-  int RT = rtimer;
-  int i,j,pTest,sizeTest,weighted,n1;
-  bigint N;
-
-  def R0 = basering;
-  list rl = ringlist(R0);
-  if((npars(R0) > 0) || (rl[1] > 0))
-  {
-    ERROR("Characteristic of basering should be zero, basering should have no parameters.");
-  }
-
-  if(typeof(II) == "ideal")
-  {
-    ideal I = II;
-    kill II;
-    list II;
-    II[1] = I;
-    II[2] = 2;
-    II[3] = 2;
-  }
-  else
-  {
-    if(typeof(II) == "list" && typeof(II[1]) == "ideal")
-    {
-      ideal I = II[1];
-      if(size(II) == 1)
-      {
-        II[2] = 2;
-        II[3] = 2;
-      }
-      if(size(II) == 2)
-      {
-        II[3] = 2;
-      }
-
-    }
-    else
-    {
-      ERROR("Unexpected type of input.");
-    }
-  }
-
-//--------------------  Initialize optional parameters  ------------------------
-  n1 = system("--cpus");
-  if(size(#) == 0)
-  {
-    int exactness = 1;
-    int n2 = 10;
-    int n3 = 10;
-  }
-  else
-  {
-    if(size(#) == 1)
-    {
-      if(typeof(#[1]) == "int")
-      {
-        if(#[1] < n1)
-        {
-          n1 = #[1];
-        }
-        int exactness = 1;
-        if(n1 >= 10)
-        {
-          int n2 = n1 + 1;
-          int n3 = n1;
-        }
-        else
-        {
-          int n2 = 10;
-          int n3 = 10;
-        }
-      }
-      else
-      {
-        ERROR("Unexpected type of input.");
-      }
-    }
-    if(size(#) == 2)
-    {
-      if(typeof(#[1]) == "int" && typeof(#[2]) == "int")
-      {
-        if(#[1] < n1)
-        {
-          n1 = #[1];
-        }
-        int exactness = #[2];
-        if(n1 >= 10)
-        {
-          int n2 = n1 + 1;
-          int n3 = n1;
-        }
-        else
-        {
-          int n2 = 10;
-          int n3 = 10;
-        }
-      }
-      else
-      {
-        if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec")
-        {
-          intvec curr_weight = #[1];
-          intvec target_weight = #[2];
-          weighted = 1;
-          int n2 = 10;
-          int n3 = 10;
-          int exactness = 1;
-        }
-        else
-        {
-          ERROR("Unexpected type of input.");
-        }
-      }
-    }
-    if(size(#) == 3)
-    {
-      if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec" && typeof(#[3]) == "int")
-      {
-        intvec curr_weight = #[1];
-        intvec target_weight = #[2];
-        weighted = 1;
-        n1 = #[3];
-        int n2 = 10;
-        int n3 = 10;
-        int exactness = 1;
-      }
-      else
-      {
-        ERROR("Unexpected type of input.");
-      }
-    }
-    if(size(#) == 4)
-    {
-      if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec" && typeof(#[3]) == "int"
-          && typeof(#[4]) == "int")
-      {
-        intvec curr_weight = #[1];
-        intvec target_weight = #[2];
-        weighted = 1;
-        if(#[1] < n1)
-        {
-          n1 = #[3];
-        }
-        int exactness = #[4];
-        if(n1 >= 10)
-        {
-          int n2 = n1 + 1;
-          int n3 = n1;
-        }
-        else
-        {
-          int n2 = 10;
-          int n3 = 10;
-        }
-      }
-      else
-      {
-        if(typeof(#[1]) == "int" && typeof(#[2]) == "int" && typeof(#[3]) == "int" && typeof(#[4]) == "int")
-        {
-          if(#[1] < n1)
-          {
-            n1 = #[1];
-          }
-          int exactness = #[2];
-          if(n1 >= #[3])
-          {
-            int n2 = n1 + 1;
-          }
-          else
-          {
-            int n2 = #[3];
-          }
-          if(n1 >= #[4])
-          {
-            int n3 = n1;
-          }
-          else
-          {
-            int n3 = #[4];
-          }
-        }
-        else
-        {
-          ERROR("Unexpected type of input.");
-        }
-      }
-    }
-    if(size(#) == 6)
-    {
-      if(typeof(#[1]) == "intvec" && typeof(#[2]) == "intvec" && typeof(#[3]) == "int" && typeof(#[4]) == "int" && typeof(#[5]) == "int" && typeof(#[6]) == "int")
-      {
-        intvec curr_weight = #[1];
-        intvec target_weight = #[2];
-        weighted = 1;
-        if(#[3] < n1)
-        {
-          n1 = #[3];
-        }
-        int exactness = #[4];
-        if(n1 >= #[5])
-        {
-          int n2 = n1 + 1;
-        }
-        else
-        {
-          int n2 = #[5];
-        }
-        if(n1 >= #[6])
-        {
-          int n3 = n1;
-        }
-        else
-        {
-          int n3 = #[6];
-        }
-      }
-      else
-      {
-        ERROR("Expected list(intvec,intvec,int,int,int,int) as optional parameter list.");
-      }
-    }
-    if(size(#) == 1 || size(#) == 5 || size(#) > 6)
-    {
-      ERROR("Expected 0,2,3,4 or 5 optional arguments.");
-    }
-  }
-  if(printlevel >= 10)
-  {
-  "n1 = "+string(n1)+", n2 = "+string(n2)+", n3 = "+string(n3)+", exactness = "+string(exactness);
-  }
-
-//-------------------------  Save current options  -----------------------------
-  intvec opt = option(get);
-  //option(redSB);
-
-//--------------------  Initialize the list of primes  -------------------------
-  int tt = timer;
-  int rt = rtimer;
-  int en = 2134567879;
-  int an = 1000000000;
-  intvec L = primeList(I,n2);
-  if(n2 > 4)
-  {
-  //  L[5] = prime(random(an,en));
-  }
-  if(printlevel >= 10)
-  {
-    "CPU-time for primeList: "+string(timer-tt)+" seconds.";
-    "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
-  }
-  int h = homog(I);
-  list P,T1,T2,LL,Arguments,PP;
-  ideal J,K,H;
-
-//-------------------  parallelized Groebner Walk in positive characteristic  --------------------
-
-  if(weighted)
-  {
-    for(i=1; i<=size(L); i++)
-    {
-      Arguments[i] = list(II,L[i],variant,list(curr_weight,target_weight));
-    }
-  }
-  else
-  {
-    for(i=1; i<=size(L); i++)
-    {
-      Arguments[i] = list(II,L[i],variant);
-    }
-  }
-  P = parallelWaitAll("modpWalk",Arguments);
-  for(i=1; i<=size(P); i++)
-  {
-    T1[i] = P[i][1];
-    T2[i] = bigint(P[i][2]);
-  }
-
-  while(1)
-  {
-    LL = deleteUnluckyPrimes(T1,T2,h);
-    T1 = LL[1];
-    T2 = LL[2];
-//-------------------  Now all leading ideals are the same  --------------------
-//-------------------  Lift results to basering via farey  ---------------------
-
-    tt = timer; rt = rtimer;
-    N = T2[1];
-    for(i=2; i<=size(T2); i++)
-    {
-      N = N*T2[i];
-    }
-    H = chinrem(T1,T2);
-    J = parallelFarey(H,N,n1);
-    //J=farey(H,N);
-    if(printlevel >= 10)
-    {
-      "CPU-time for lifting-process is "+string(timer - tt)+" seconds.";
-      "Real-time for lifting-process is "+string(rtimer - rt)+" seconds.";
-    }
-
-//----------------  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);
-    if(printlevel >= 10)
-    {
-      "CPU-time for pTest is "+string(timer - tt)+" seconds.";
-      "Real-time for pTest is "+string(rtimer - rt)+" seconds.";
-    }
-    if(pTest)
-    {
-      if(printlevel >= 10)
-      {
-        "CPU-time for computation without final tests is "+string(timer - TT)+" seconds.";
-        "Real-time for computation without final tests is "+string(rtimer - RT)+" seconds.";
-      }
-      attrib(J,"isSB",1);
-      if(exactness == 0)
-      {
-        option(set, opt);
-        return(J);
-      }
-      else
-      {
-        tt = timer;
-        rt = rtimer;
-        sizeTest = 1 - isIdealIncluded(I,J,n1);
-        if(printlevel >= 10)
-        {
-          "CPU-time for checking if I subset <G> is "+string(timer - tt)+" seconds.";
-          "Real-time for checking if I subset <G> is "+string(rtimer - rt)+" seconds.";
-        }
-        if(sizeTest == 0)
-        {
-          tt = timer;
-          rt = rtimer;
-          K = std(J);
-          if(printlevel >= 10)
-          {
-            "CPU-time for last std-computation is "+string(timer - tt)+" seconds.";
-            "Real-time for last std-computation is "+string(rtimer - rt)+" seconds.";
-          }
-          if(size(reduce(K,J)) == 0)
-          {
-            option(set, opt);
-            return(J);
-          }
-        }
-      }
-    }
-//--------------  We do not already have a standard basis of I, therefore do the main computation for more primes  --------------
-
-    T1 = H;
-    T2 = N;
-    j = size(L)+1;
-    tt = timer; rt = rtimer;
-    L = primeList(I,n3,L,n1);
-    if(printlevel >= 10)
-    {
-      "CPU-time for primeList: "+string(timer-tt)+" seconds.";
-      "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
-    }
-    Arguments = list();
-    PP = list();
-    if(weighted)
-    {
-      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));
-      }
-    }
-    else
-    {
-      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);
-      }
-    }
-    PP = parallelWaitAll("modpWalk",Arguments);
-    if(printlevel >= 10)
-    {
-      "parallel modpWalk";
-    }
-    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]);
-    }
-  }
-  if(printlevel >= 10)
-  {
-    "CPU-time for computation with final tests is "+string(timer - TT)+" seconds.";
-    "Real-time for computation with final tests is "+string(rtimer - RT)+" seconds.";
-  }
-}
-
-example
-{
-  "EXAMPLE:";
-  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);
-  J;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static proc isIdealIncluded(ideal I, ideal J, int n1)
-"USAGE:  isIdealIncluded(I,J,int n1); I ideal, J ideal, n1 integer
-"
-{
-  if(n1 > 1)
-  {
-    int k;
-    list args,results;
-    for(k=1; k<=size(I); k++)
-    {
-      args[k] = list(ideal(I[k]),J,1);
-    }
-    results = parallelWaitAll("reduce",args);
-    for(k=1; k<=size(results); k++)
-    {
-      if(results[k] == 0)
-      {
-        return(1);
-      }
-    }
-    return(0);
-  }
-  else
-  {
-    if(reduce(I,J,1) == 0)
-    {
-      return(1);
-    }
-    else
-    {
-      return(0);
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static proc parallelChinrem(list T1, list T2, int n1)
-"USAGE:  parallelChinrem(T1,T2); T1 list of ideals, T2 list of primes, n1 integer"
-{
-  int i,j,k;
-
-  ideal H,J;
-
-  list arguments_chinrem,results_chinrem;
-  for(i=1; i<=size(T1); i++)
-  {
-    J = ideal(T1[i]);
-    attrib(J,"isSB",1);
-    arguments_chinrem[size(arguments_chinrem)+1] = list(list(J),T2);
-  }
-  results_chinrem = parallelWaitAll("chinrem",arguments_chinrem);
-    for(j=1; j <= size(results_chinrem); j++)
-    {
-      J = results_chinrem[j];
-      attrib(J,"isSB",1);
-      if(isIdealIncluded(J,H,n1) == 0)
-      {
-        if(H == 0)
-        {
-          H = J;
-        }
-        else
-        {
-          H = H,J;
-        }
-      }
-    }
-  return(H);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-static proc parallelFarey(ideal H, bigint N, int n1)
-"USAGE:  parallelFarey(H,N,n1); H ideal, N bigint, n1 integer
-"
-{
-  int i,j;
-  int ii = 1;
-  list arguments_farey,results_farey;
-  for(i=1; i<=size(H); i++)
-  {
-    for(j=1; j<=size(H[i]); j++)
-    {
-      arguments_farey[size(arguments_farey)+1] = list(H[i][j],N);
-    }
-  }
-  results_farey = parallelWaitAll("farey",arguments_farey);
-  ideal J,K;
-  poly f_farey;
-  while(ii<=size(results_farey))
-  {
-    for(i=1; i<=size(H); i++)
-    {
-      f_farey = 0;
-      for(j=1; j<=size(H[i]); j++)
-      {
-        f_farey = f_farey + results_farey[ii][1];
-        ii++;
-      }
-      K = ideal(f_farey);
-      attrib(K,"isSB",1);
-      attrib(J,"isSB",1);
-      if(isIdealIncluded(K,J,n1) == 0)
-      {
-        if(J == 0)
-        {
-          J = K;
-        }
-        else
-        {
-          J = J,K;
-        }
-      }
-    }
-  }
-  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()
-"USAGE:  mixedTest();
-RETURN:  1 if ordering of basering is mixed, 0 else
-EXAMPLE: example mixedTest(); shows an example
-"
-{
-   int i,p,m;
-   for(i = 1; i <= nvars(basering); i++)
-   {
-      if(var(i) > 1)
-      {
-         p++;
-      }
-      else
-      {
-         m++;
-      }
-   }
-   if((p > 0) && (m > 0)) { return(1); }
-   return(0);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   ring R1 = 0,(x,y,z),dp;
-   mixedTest();
-   ring R2 = 31,(x(1..4),y(1..3)),(ds(4),lp(3));
-   mixedTest();
-   ring R3 = 181,x(1..9),(dp(5),lp(4));
-   mixedTest();
-}
+    int pertdeg = 3;
+    ideal J = modrWalk(I,radius,pertdeg);
+    J;
+}
+
+proc modfWalk(ideal I, list #)
+"USAGE:   modfWalk(I, [, v, w]); I ideal, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modfWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("fwalk", list(I,reduction,printout,#));
+    }
+    else {
+        I = modular("fwalk", list(I,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
+    ideal J = modfWalk(I);
+    J;
+}
+
+proc modfrWalk(ideal I, int radius, list #)
+"USAGE:   modfrWalk(I, radius [, v, w]); I ideal, radius int, v intvec, w intvec
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+SEE ALSO: modular
+EXAMPLE:  example modfrWalk; shows an example"
+{
+    /* read optional parameter */
+    if (size(#) > 0) {
+        if (size(#) == 1) {
+            intvec w = #[1];
+        }
+        if (size(#) == 2) {
+            intvec v = #[1];
+            intvec w = #[2];
+        }
+        if (size(#) > 2 || typeof(#[1]) != "intvec") {
+            ERROR("wrong optional parameter");
+        }
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* set additional parameters */
+    int reduction = 1;
+    int printout = 0;
+
+    /* call modular() */
+    if (size(#) > 0) {
+        I = modular("frandwalk", list(I,radius,reduction,printout,#));
+    }
+    else {
+        I = modular("frandwalk", list(I,radius,reduction,printout));
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    I = std(I);
+    ring R2 = 0, (x,y,z,t), lp;
+    ideal I = fetch(R1, I);
+    int radius = 2;
+    ideal J = modfrWalk(I,radius);
+    J;
+}

Singular/LIB/nfmodstd.lib

@@ -524 +524 @@
     I;
 }
+
+//////////////////////////////////////////////////////////////////////////////
+
+/*
+Benchmark Problems from
+
+Boku, Decker, Fieker, Steenpass: Groebner Bases over Algebraic Number
+Fields.
+
+// 1
+ring R = (0,a), (x,y,z), dp;
+minpoly = (a^2+1);
+poly f1 = (a+8)*x^2*y^2+5*x*y^3+(-a+3)*x^3*z
+          +x^2*y*z;
+poly f2 = x^5+2*y^3*z^2+13*y^2*z^3+5*y*z^4;
+poly f3 = 8*x^3+(a+12)*y^3+x*z^2+3;
+poly f4 = (-a+7)*x^2*y^4+y^3*z^3+18*y^3*z^2;
+ideal I1 = f1,f2,f3,f4;
+
+// 2
+ring R = (0,a), (x,y,z), dp;
+minpoly = (a^5+a^2+2);
+poly f1 = 2*x*y^4*z^2+(a-1)*x^2*y^3*z
+          +(2*a)*x*y*z^2+7*y^3+(7*a+1);
+poly f2 = 2*x^2*y^4*z+(a)*x^2*y*z^2-x*y^2*z^2
+          +(2*a+3)*x^2*y*z-12*x+(12*a)*y;
+poly f3 = (2*a)*y^5*z+x^2*y^2*z-x*y^3*z
+          +(-a)*x*y^3+y^4+2*y^2*z;
+poly f4 = (3*a)*x*y^4*z^3+(a+1)*x^2*y^2*z
+          -x*y^3*z+4*y^3*z^2+(3*a)*x*y*z^3
+          +4*z^2-x+(a)*y;
+ideal I2 = f1,f2,f3,f4;
+
+// 3a
+ring R = (0,a), (v,w,x,y,z), dp;
+minpoly = (a^7-7*a+3);
+poly f1 = (a)*v+(a-1)*w+x+(a+2)*y+z;
+poly f2 = v*w+(a-1)*w*x+(a+2)*v*y+x*y+(a)*y*z;
+poly f3 = (a)*v*w*x+(a+5)*w*x*y+(a)*v*w*z
+          +(a+2)*v*y*z+(a)*x*y*z;
+poly f4 = (a-11)*v*w*x*y+(a+5)*v*w*x*z
+          +(a)*v*w*y*z+(a)*v*x*y*z
+          +(a)*w*x*y*z;
+poly f5 = (a+3)*v*w*x*y*z+(a+23);
+ideal I3a = f1,f2,f3,f4,f5;
+
+// 3b
+ring R = (0,a), (u,v,w,x,y,z), dp;
+minpoly = (a^7-7*a+3);
+poly f1 = (a)*u+(a+2)*v+w+x+y+z;
+poly f2 = u*v+v*w+w*x+x*y+(a+3)*u*z+y*z;
+poly f3 = u*v*w+v*w*x+(a+1)*w*x*y+u*v*z+u*y*z
+          +x*y*z;
+poly f4 = (a-1)*u*v*w*x+v*w*x*y+u*v*w*z
+          +u*v*y*z+u*x*y*z+w*x*y*z;
+poly f5 = u*v*w*x*y+(a+1)*u*v*w*x*z+u*v*w*y*z
+          +u*v*x*y*z+u*w*x*y*z+v*w*x*y*z;
+poly f6 = u*v*w*x*y*z+(-a+2);
+ideal I3b = f1,f2,f3,f4,f5,f6;
+
+// 4
+ring R = (0,a), (w,x,y,z), dp;
+minpoly = (a^6+a^5+a^4+a^3+a^2+a+1);
+poly f1 = (a+5)*w^3*x^2*y+(a-3)*w^2*x^3*y
+          +(a+7)*w*x^2*y^2;
+poly f2 = (a)*w^5+(a+3)*w*x^2*y^2
+          +(a^2+11)*x^2*y^2*z;
+poly f3 = (a+7)*w^3+12*x^3+4*w*x*y+(a)*z^3;
+poly f4 = 3*w^3+(a-4)*x^3+x*y^2;
+ideal I4 = f1,f2,f3,f4;
+
+// 5
+ring R = (0,a), (w,x,y,z), dp;
+minpoly = (a^12-5*a^11+24*a^10-115*a^9+551*a^8
+          -2640*a^7+12649*a^6-2640*a^5+551*a^4
+          -115*a^3+24*a^2-5*a+1);
+poly f1 = (2*a+3)*w*x^4*y^2+(a+1)*w^2*x^3*y*z
+          +2*w*x*y^2*z^3+(7*a-1)*x^3*z^4;
+poly f2 = 2*w^2*x^4*y+w^2*x*y^2*z^2
+          +(-a)*w*x^2*y^2*z^2
+          +(a+11)*w^2*x*y*z^3-12*w*z^6
+          +12*x*z^6;
+poly f3 = 2*x^5*y+w^2*x^2*y*z-w*x^3*y*z
+          -w*x^3*z^2+(a)*x^4*z^2+2*x^2*y*z^3;
+poly f4 = 3*w*x^4*y^3+w^2*x^2*y*z^3
+          -w*x^3*y*z^3+(a+4)*x^3*y^2*z^3
+          +3*w*x*y^3*z^3+(4*a)*y^2*z^6-w*z^7
+          +x*z^7;
+ideal I5 = f1,f2,f3,f4;
+
+// 6
+ring R = (0,a), (u,v,w,x,y,z), dp;
+minpoly = (a^2+5*a+1);
+poly f1 = u+v+w+x+y+z+(a);
+poly f2 = u*v+v*w+w*x+x*y+y*z+(a)*u+(a)*z;
+poly f3 = u*v*w+v*w*x+w*x*y+x*y*z+(a)*u*v
+          +(a)*u*z+(a)*y*z;
+poly f4 = u*v*w*x+v*w*x*y+w*x*y*z+(a)*u*v*w
+          +(a)*u*v*z+(a)*u*y*z+(a)*x*y*z;
+poly f5 = u*v*w*x*y+v*w*x*y*z+(a)*u*v*w*x
+          +(a)*u*v*w*z+(a)*u*v*y*z+(a)*u*x*y*z
+          +(a)*w*x*y*z;
+poly f6 = u*v*w*x*y*z+(a)*u*v*w*x*y
+          +(a)*u*v*w*x*z+(a)*u*v*w*y*z
+          +(a)*u*v*x*y*z+(a)*u*w*x*y*z
+          +(a)*v*w*x*y*z;
+poly f7 = (a)*u*v*w*x*y*z-1;
+ideal I6 = f1,f2,f3,f4,f5,f6,f7;
+
+// 7
+ring R = (0,a), (w,x,y,z), dp;
+minpoly = (a^8-16*a^7+19*a^6-a^5-5*a^4+13*a^3
+          -9*a^2+13*a+17);
+poly f1 = (-a^2-1)*x^2*y+2*w*x*z-2*w
+          +(a^2+1)*y;
+poly f2 = (a^3-a-3)*w^3*y+4*w*x^2*y+4*w^2*x*z
+          +2*x^3*z+(a)*w^2-10*x^2+4*w*y-10*x*z
+          +(2*a^2+a);
+poly f3 = (a^2+a+11)*x*y*z+w*z^2-w-2*y;
+poly f4 = -w*y^3+4*x*y^2*z+4*w*y*z^2+2*x*z^3
+          +(2*a^3+a^2)*w*y+4*y^2-10*x*z-10*z^2
+          +(3*a^2+5);
+ideal I7 = f1,f2,f3,f4;
+
+// 8
+ring R = (0,a), (t,u,v,w,x,y,z), dp;
+minpoly = (a^7+10*a^5+5*a^3+10*a+1);
+poly f1 = v*x+w*y-x*z-w-y;
+poly f2 = v*w-u*x+x*y-w*z+v+x+z;
+poly f3 = t*w-w^2+x^2-t;
+poly f4 = (-a)*v^2-u*y+y^2-v*z-z^2+u;
+poly f5 = t*v+v*w+(-a^2-a-5)*x*y-t*z+w*z+v+x+z
+          +(a+1);
+poly f6 = t*u+u*w+(-a-11)*v*x-t*y+w*y-x*z-t-u
+          +w+y;
+poly f7 = w^2*y^3-w*x*y^3+x^2*y^3+w^2*y^2*z
+          -w*x*y^2*z+x^2*y^2*z+w^2*y*z^2
+          -w*x*y*z^2+x^2*y*z^2+w^2*z^3-w*x*z^3
+          +x^2*z^3;
+poly f8 = t^2*u^3+t^2*u^2*v+t^2*u*v^2+t^2*v^3
+          -t*u^3*x-t*u^2*v*x-t*u*v^2*x-t*v^3*x
+          +u^3*x^2+u^2*v*x^2+u*v^2*x^2
+          +v^3*x^2;
+ideal I8 = f1,f2,f3,f4,f5,f6,f7,f8;
+*/

Singular/LIB/primdec.lib

@@ -807 +807 @@
         if((size(sact)==1)&&(m==2))
         {
-          l[2*i]=l[2*i-1];
-          attrib(l[2*i],"isSB",1);
+          l[2*i]=std(l[2*i-1],sact[1]);
         }
         if((size(sact)==1)&&(m>2))
@@ -875 +874 @@
   int uytrewq;
   int nva = nvars(basering);
-  int @k,@s,@n,@k1,zz;
+  int @k,@s,@n,@k1,@zz;
   list primary,lres0,lres1,act,@lh,@wh;
   map phi,psi,phi1,psi1;
@@ -1056 +1055 @@
   {
     poly randp;
-    for(zz=1;zz<nvars(basering);zz++)
+    for(@zz=1;@zz<nvars(basering);@zz++)
     {
       randp=randp
-              +(random(0,5)*par(1)^2+random(0,5)*par(1)+random(0,5))*var(zz);
+              +(random(0,5)*par(1)^2+random(0,5)*par(1)+random(0,5))*var(@zz);
     }
     randp=randp+var(nvars(basering));
@@ -1069 +1068 @@
     if (size(primary[2*@k])==0)
     {
-      for(zz=1;zz<size(primary[2*@k-1])-1;zz++)
+      for(@zz=1;@zz<size(primary[2*@k-1])-1;@zz++)
       {
         attrib(primary[2*@k-1],"isSB",1);
-        if(vdim(primary[2*@k-1])==deg(primary[2*@k-1][zz]))
+        if(vdim(primary[2*@k-1])==deg(primary[2*@k-1][@zz]))
         {
           primary[2*@k]=primary[2*@k-1];
@@ -1100 +1099 @@
         if(deg(lead(primary[2*@k-1][@n]))==1)
         {
-          for(zz=1;zz<=nva;zz++)
+          for(@zz=1;@zz<=nva;@zz++)
           {
-            if(lead(primary[2*@k-1][@n])/var(zz)!=0)
+            if(lead(primary[2*@k-1][@n])/var(@zz)!=0)
             {
-              jmap1[zz]=-1/leadcoef(primary[2*@k-1][@n])*primary[2*@k-1][@n]
+              jmap1[@zz]=-1/leadcoef(primary[2*@k-1][@n])*primary[2*@k-1][@n]
                    +2/leadcoef(primary[2*@k-1][@n])*lead(primary[2*@k-1][@n]);
-              jmap2[zz]=primary[2*@k-1][@n];
-              @qht[@n]=var(zz);
+              jmap2[@zz]=primary[2*@k-1][@n];
+              @qht[@n]=var(@zz);
             }
           }
@@ -9024 +9023 @@
   int uytrewq;
   int nva = nvars(basering);
-  int @k,@s,@n,@k1,zz;
+  int @k,@s,@n,@k1,@zz;
   list primary,lres0,lres1,act,@lh,@wh;
   map phi,psi,phi1,psi1;
@@ -9207 +9206 @@
   {
     poly randp;
-    for(zz=1;zz<nvars(basering);zz++)
+    for(@zz=1;@zz<nvars(basering);@zz++)
     {
       randp=randp
-              +(random(0,5)*par(1)^2+random(0,5)*par(1)+random(0,5))*var(zz);
+              +(random(0,5)*par(1)^2+random(0,5)*par(1)+random(0,5))*var(@zz);
     }
     randp=randp+var(nvars(basering));
@@ -9220 +9219 @@
     if (size(primary[2*@k])==0)
     {
-      for(zz=1;zz<size(primary[2*@k-1])-1;zz++)
+      for(@zz=1;@zz<size(primary[2*@k-1])-1;@zz++)
       {
         attrib(primary[2*@k-1],"isSB",1);
-        if(vdim(primary[2*@k-1])==deg(primary[2*@k-1][zz]))
+        if(vdim(primary[2*@k-1])==deg(primary[2*@k-1][@zz]))
         {
           primary[2*@k]=primary[2*@k-1];
@@ -9251 +9250 @@
         if(deg(lead(primary[2*@k-1][@n]))==1)
         {
-          for(zz=1;zz<=nva;zz++)
+          for(@zz=1;@zz<=nva;@zz++)
           {
-            if(lead(primary[2*@k-1][@n])/var(zz)!=0)
+            if(lead(primary[2*@k-1][@n])/var(@zz)!=0)
             {
-              jmap1[zz]=-1/leadcoef(primary[2*@k-1][@n])*primary[2*@k-1][@n]
+              jmap1[@zz]=-1/leadcoef(primary[2*@k-1][@n])*primary[2*@k-1][@n]
                    +2/leadcoef(primary[2*@k-1][@n])*lead(primary[2*@k-1][@n]);
-              jmap2[zz]=primary[2*@k-1][@n];
-              @qht[@n]=var(zz);
+              jmap2[@zz]=primary[2*@k-1][@n];
+              @qht[@n]=var(@zz);
             }
           }

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/surf.lib

@@ -274 +274 @@
 
   string surf_call; i = 0;
-  
+
   if (isWindows())
   {
@@ -303 +303 @@
   else
   {
-    surf_call = "surfer";    
+    surf_call = "surfer";
     surf_call = surf_call + " " + l + " >/dev/null 2>&1";
     "Close window to exit from `surfer`.";
     i = system("sh", surf_call);
-    
-    if ( (i != 0) && isMacOSX() ) 
+
+    if ( (i != 0) && isMacOSX() )
     {
       "*!* Sorry: calling `surfer` failed ['"+surf_call+"']" + newline
       + " (The shell returned the error code " + string(i) + "." + newline
-      + "But since we are on Mac OS X, let us try to open SURFER.app instead..." + newline 
+      + "But since we are on Mac OS X, let us try to open SURFER.app instead..." + newline
       + "Appropriate SURFER.app is available for instance at http://www.mathematik.uni-kl.de/~motsak/files/SURFER.dmg";
-      
+
       // fallback, will only work if SURFER.app is available (e.g. in /Applications)
       // get SURFER.app e.g. from http://www.mathematik.uni-kl.de/~motsak/files/SURFER.dmg
       // note that the newer (Java-based) variant of Surfer may not support command line usage yet :(
-      
+
       surf_call = "open -a SURFER -W --args -t -s";
       surf_call = surf_call + " " + l + " >/dev/null 2>&1";
@@ -324 +324 @@
       i = system("sh", surf_call);
     }
-    
-    
-    
+
+
+
   }
   system("sh", "/bin/rm " + l);
@@ -381 +381 @@
 {
   string s = system("uname");
-  
+
   for (int i = 1; i <= size(s)-2; i = i + 1)
   {

Singular/Makefile.am

@@ -98 +98 @@
    mmalloc.h \
    mod_lib.h \
-   omSingularConfig.h \
    links/ndbm.h \
    newstruct.h \

Singular/dyn_modules/singmathic/singmathic.cc

@@ -468 +468 @@
   result->rtyp=NONE;
 
-  if (arg == NULL || arg->next != NULL || 
+  if (arg == NULL || arg->next != NULL ||
   ((arg->Typ() != IDEAL_CMD) &&(arg->Typ() != MODUL_CMD))){
     WerrorS("Syntax: mathicgb(<ideal>/<module>)");

Singular/dyn_modules/syzextra/mod_main.cc

@@ -82 +82 @@
     for (int j=0; j<l; j++)
       if (id->m[j] != NULL && p_GetComp(id->m[j], r) > 0)
-        return TRUE;    
+        return TRUE;
 
     return FALSE; // rank: 1, only zero or no entries? can be an ideal OR module... BUT in the use-case should better be an ideal!
@@ -91 +91 @@
 
 
-   
+
 
 static inline void NoReturn(leftv& res)
@@ -1550 +1550 @@
   const int iLimit = r->typ[pos].data.is.limit;
   const ideal F = r->typ[pos].data.is.F;
-  
+
   ideal FF = id_Copy(F, r);
 

Singular/extra.cc

@@ -3794 +3794 @@
     }
     else
-#endif    
+#endif
 /*==================== Error =================*/
       Werror( "(extended) system(\"%s\",...) %s", sys_cmd, feNotImplemented );

Singular/maps_ip.cc

@@ -73 +73 @@
       if (P!=0)
       {
-//        WerrorS("Sorry 'napPermNumber' was lost in the refactoring process (due to Frank): needs to be fixed");
-//        return TRUE;
-#if 1
 // poly n_PermNumber(const number z, const int *par_perm, const int OldPar, const ring src, const ring dst);
         res->data= (void *) n_PermNumber((number)data, par_perm, P, preimage_r, currRing);
-#endif
         res->rtyp=POLY_CMD;
         if (nCoeff_is_algExt(currRing->cf))
@@ -87 +83 @@
       {
         assume( nMap != NULL );
-
         number a = nMap((number)data, preimage_r->cf, currRing->cf);
         if (nCoeff_is_Extension(currRing->cf))
@@ -150 +145 @@
         }
       }
-      else
-      if ( (what==IMAP_CMD) || /*(*/ (what==FETCH_CMD) /*)*/) /* && (nMap!=nCopy)*/
+      else if ((what==IMAP_CMD) || (what==FETCH_CMD))
       {
         for (i=R*C-1;i>=0;i--)
@@ -160 +154 @@
         }
       }
-      else /* if(what==MAP_CMD) */
-      {
+      else /* (what==MAP_CMD) */
+      {
+        assume(what==MAP_CMD);
         matrix s=mpNew(N,maMaxDeg_Ma((ideal)data,preimage_r));
         for (i=R*C-1;i>=0;i--)
@@ -170 +165 @@
         idDelete((ideal *)&s);
       }
-      if (nCoeff_is_Extension(currRing->cf))
+      if (nCoeff_is_algExt(currRing->cf))
       {
         for (i=R*C-1;i>=0;i--)

Singular/misc_ip.cc

@@ -716 +716 @@
   } while (v!=NULL);
 
-#ifdef OM_SINGULAR_CONFIG_H
    // set global variable to show memory usage
   extern int om_sing_opt_show_mem;
   if (BVERBOSE(V_SHOW_MEM)) om_sing_opt_show_mem = 1;
   else om_sing_opt_show_mem = 0;
-#endif
 
   return FALSE;
@@ -1095 +1093 @@
 #endif   // HAVE_SIMPLEIPC
     fe_reset_input_mode();
+    monitor(NULL,0);
 #ifdef PAGE_TEST
     mmEndStat();

Singular/test.cc

@@ -194 +194 @@
 #include <Singular/links/ndbm.h>
 #include <Singular/newstruct.h>
-#include <Singular/omSingularConfig.h>
 #include <Singular/pcv.h>
 #include <Singular/links/pipeLink.h>

Singular/walk.cc

@@ -27 +27 @@
 
 #define FIRST_STEP_FRACTAL // to define the first step of the fractal
-//#define MSTDCC_FRACTAL // apply Buchberger alg to compute a red GB, if
+#define MSTDCC_FRACTAL // apply Buchberger alg to compute a red GB, if
 //                          tau doesn't stay in the correct cone
 
@@ -42 +42 @@
 #include <Singular/ipshell.h>
 #include <Singular/ipconv.h>
+#include <coeffs/ffields.h>
 #include <coeffs/coeffs.h>
 #include <Singular/subexpr.h>
+#include <polys/templates/p_Procs.h>
 
 #include <polys/monomials/maps.h>
@@ -429 +431 @@
 #endif
 
-#ifdef CHECK_IDEAL_MWALK
+//#ifdef CHECK_IDEAL_MWALK
 static void idString(ideal L, const char* st)
 {
@@ -441 +443 @@
   Print(" %s;", pString(L->m[nL-1]));
 }
-#endif
+//#endif
 
 #if defined(CHECK_IDEAL_MWALK) || defined(ENDWALKS)
@@ -511 +513 @@
 
 //unused
-#if 0
+//#if 0
 static void MivString(intvec* iva, intvec* ivb, intvec* ivc)
 {
@@ -534 +536 @@
   Print("%d)", (*ivc)[nV]);
 }
-#endif
+//#endif
 
 /********************************************************************
@@ -558 +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;
 }
 
@@ -774 +806 @@
   for(i=nG-1; i>=0; i--)
   {
-    mi = MpolyInitialForm(G->m[i], iv);
-    gi = G->m[i];
-
+    mi = pHead(MpolyInitialForm(G->m[i], iv));
+    //Print("\n **// test_w_in_ConeCC: lm(initial)= %s \n",pString(mi));
+    gi = pHead(G->m[i]);
+    //Print("\n **// test_w_in_ConeCC: lm(ideal)= %s \n",pString(gi));
     if(mi == NULL)
     {
@@ -953 +986 @@
 }
 
-/*****************************************************************************
-* 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);
 
@@ -966 +999 @@
   {
     (*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;
@@ -1612 +1647 @@
     (* result)[i] = mpz_get_si(pert_vector[i]);
   }
-
+/*
   j = 0;
-  for(i=0; i<nV; i++)
+  for(i=0; i<niv; i++)
   {
     (* result1)[i] = mpz_get_si(pert_vector[i]);
@@ -1624 +1659 @@
     }
   }
-  if(j > nV - 1)
+  if(j > niv - 1)
   {
     // Print("\n//  MfPertwalk: geaenderter vector gleich Null! \n");
@@ -1630 +1665 @@
     goto CHECK_OVERFLOW;
   }
-
+/*
 // check that the perturbed weight vector lies in the Groebner cone
+  Print("\n========================================\n//** MfPertvector: test in Cone.\n");
   if(test_w_in_ConeCC(G,result1) != 0)
   {
@@ -1647 +1683 @@
     // Print("\n// Mfpertwalk: geaenderter vector liegt nicht in Groebnerkegel! \n");
   }
-
+  Print("\n ========================================\n");*/
   CHECK_OVERFLOW:
 
@@ -1859 +1895 @@
 }
 
+
+/**************************************************************
+ * 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 *
@@ -1873 +1929 @@
 
   int nRing = currRing->N;
-  int checkRed, j, kkk, nG = IDELEMS(G);
+  int checkRed, j, nG = IDELEMS(G);
   intvec* ivtemp;
 
@@ -1911 +1967 @@
   mpz_init(dcw);
 
-  //int tn0, tn1, tz1, ncmp, gcd_tmp, ntmp;
   int gcd_tmp;
   intvec* diff_weight = MivSub(target_weight, curr_weight);
@@ -1917 +1972 @@
   intvec* diff_weight1 = MivSub(target_weight, curr_weight);
   poly g;
-  //poly g, gw;
+
   for (j=0; j<nG; j++)
   {
@@ -1934 +1989 @@
         mpz_set_si(MwWd, MivDotProduct(ivtemp, curr_weight));
         mpz_sub(s_zaehler, deg_w0_p1, MwWd);
-
         if(mpz_cmp(s_zaehler, t_null) != 0)
         {
           mpz_set_si(MwWd, MivDotProduct(ivtemp, diff_weight));
           mpz_sub(s_nenner, MwWd, deg_d0_p1);
-
           // check for 0 < s <= 1
           if( (mpz_cmp(s_zaehler,t_null) > 0 &&
@@ -1979 +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)
   {
@@ -2054 +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++)
   {
@@ -2100 +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: ");
@@ -2106 +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++)
     {
@@ -2129 +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;
   }
 
@@ -2222 +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)
     {
@@ -2271 +2302 @@
 }
 
-/**************************************************************
+/********************************************************************
  * define and execute a new ring which order is (a(vb),a(va),lp,C)  *
- * ************************************************************/
-#if 0
-// unused
+ * ******************************************************************/
 static void VMrHomogeneous(intvec* va, intvec* vb)
 {
@@ -2353 +2382 @@
   rChangeCurrRing(r);
 }
-#endif
+
 
 /**************************************************************
@@ -2428 +2457 @@
 }
 
-static ring VMrDefault1(intvec* va)
-{
-
-  if ((currRing->ppNoether)!=NULL)
-  {
-    pDelete(&(currRing->ppNoether));
-  }
-  if (((sLastPrinted.rtyp>BEGIN_RING) && (sLastPrinted.rtyp<END_RING)) ||
-      ((sLastPrinted.rtyp==LIST_CMD)&&(lRingDependend((lists)sLastPrinted.data))))
-  {
-    sLastPrinted.CleanUp();
-  }
-
-  ring r = (ring) omAlloc0Bin(sip_sring_bin);
-  int i, nv = currRing->N;
-
-  r->cf  = currRing->cf;
-  r->N   = currRing->N;
-
-  int nb = 4;
-
-  //names
-  char* Q; // In order to avoid the corrupted memory, do not change.
-  r->names = (char **) omAlloc0(nv * sizeof(char_ptr));
-  for(i=0; i<nv; i++)
-  {
-    Q = currRing->names[i];
-    r->names[i]  = omStrDup(Q);
-  }
-
-  /*weights: entries for 3 blocks: NULL Made:???*/
-  r->wvhdl = (int **)omAlloc0(nb * sizeof(int_ptr));
-  r->wvhdl[0] = (int*) omAlloc(nv*sizeof(int));
-  for(i=0; i<nv; i++)
-    r->wvhdl[0][i] = (*va)[i];
-
-  /* order: a,lp,C,0 */
-  r->order = (int *) omAlloc(nb * sizeof(int *));
-  r->block0 = (int *)omAlloc0(nb * sizeof(int *));
-  r->block1 = (int *)omAlloc0(nb * sizeof(int *));
-
-  // ringorder a for the first block: var 1..nv
-  r->order[0]  = ringorder_a;
-  r->block0[0] = 1;
-  r->block1[0] = nv;
-
-  // ringorder lp for the second block: var 1..nv
-  r->order[1]  = ringorder_lp;
-  r->block0[1] = 1;
-  r->block1[1] = nv;
-
-  // ringorder C for the third block
-  // it is very important within "idLift",
-  // especially, by ring syz_ring=rCurrRingAssure_SyzComp();
-  // therefore, nb  must be (nBlocks(currRing)  + 1)
-  r->order[2]  = ringorder_C;
-
-  // the last block: everything is 0
-  r->order[3]  = 0;
-
-  // polynomial ring
-  r->OrdSgn    = 1;
-
-  // complete ring intializations
-
-  rComplete(r);
-
-  //rChangeCurrRing(r);
-  return r;
-}
-
 /****************************************************************
  * define and execute a new ring with ordering (a(va),Wp(vb),C) *
  * **************************************************************/
-
 static ring VMrRefine(intvec* va, intvec* vb)
 {
@@ -2576 +2533 @@
 
   // complete ring intializations
-
+  
   rComplete(r);
 
@@ -2806 +2763 @@
 }
 
-
-/* define a ring with parameters und change to it */
-/* DefRingPar and DefRingParlp corrupt still memory */
+/***************************************************
+* define a ring with parameters und change to it   *
+* DefRingPar and DefRingParlp corrupt still memory *
+****************************************************/
 static void DefRingPar(intvec* va)
 {
@@ -2956 +2914 @@
 }
 
-//unused
-/**************************************************************
- * check wheather one or more components of a vector are zero *
- **************************************************************/
-#if 0
+/*************************************************************
+ * check whether one or more components of a vector are zero *
+ *************************************************************/
 static int isNolVector(intvec* hilb)
 {
@@ -2973 +2929 @@
   return 0;
 }
-#endif
+
+/*************************************************************
+ * check whether one or more components of a vector are <= 0 *
+ *************************************************************/
+static int isNegNolVector(intvec* hilb)
+{
+  int i;
+  for(i=hilb->length()-1; i>=0; i--)
+  {
+    if((* hilb)[i]<=0)
+    {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+/**************************************************************************
+* Gomega is the initial ideal of G w. r. t. the current weight vector     *
+* curr_weight. Check whether curr_weight lies on a border of the Groebner *
+* cone, i. e. check whether a monomial is divisible by a leading monomial *
+***************************************************************************/
+static ideal middleOfCone(ideal G, ideal Gomega)
+{
+  BOOLEAN middle = FALSE;
+  int i,j,N = IDELEMS(Gomega);
+  poly p,lm,factor1,factor2;
+  //PrintS("\n//** idCopy\n");
+  ideal Go = idCopy(G);
+  
+  //PrintS("\n//** jetzt for-Loop!\n");
+
+  // check whether leading monomials of G and Gomega coincide
+  // and return NULL if not
+  for(i=0; i<N; i++)
+  {
+    p = pCopy(Gomega->m[i]);
+    lm = pCopy(pHead(G->m[i]));
+    if(!pIsConstant(pSub(p,lm)))
+    {
+      //pDelete(&p);
+      //pDelete(&lm);
+      idDelete(&Go);
+      return NULL; 
+    }
+    //pDelete(&p);
+    //pDelete(&lm);
+  }
+  for(i=0; i<N; i++)
+  {
+    for(j=0; j<N; j++)
+    {
+      if(i!=j)
+      {
+        p = pCopy(Gomega->m[i]);
+        lm = pCopy(Gomega->m[j]);
+        pIter(p);
+        while(p!=NULL)
+        {
+          if(pDivisibleBy(lm,p))
+          {
+            if(middle == FALSE)
+            {
+              middle = TRUE;
+            }
+            factor1 = singclap_pdivide(pHead(p),lm,currRing);
+            factor2 = pMult(pCopy(factor1),pCopy(Go->m[j]));
+            pDelete(&factor1);
+            Go->m[i] = pAdd((Go->m[i]),pNeg(pCopy(factor2)));
+            pDelete(&factor2);
+          }
+          pIter(p);
+        }
+        pDelete(&lm);
+        pDelete(&p);
+      }
+    }
+  }
+  
+  //PrintS("\n//** jetzt Delete!\n");
+  //pDelete(&p);
+  //pDelete(&factor);
+  //pDelete(&lm);
+  if(middle == TRUE)
+  {
+    //PrintS("\n//** middle TRUE!\n");
+    return Go;
+  }
+  //PrintS("\n//** middle FALSE!\n");
+  idDelete(&Go);
+  return NULL; 
+}
 
 /******************************  Februar 2002  ****************************
@@ -3128 +3175 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -3280 +3327 @@
   }
   return 0;
+}
+
+/*****************************************
+ * return maximal polynomial length of G *
+ *****************************************/
+static int maxlengthpoly(ideal G)
+{
+  int i,k,length=0;
+  for(i=IDELEMS(G)-1; i>=0; i--)
+  {
+    k = pLength(G->m[i]);
+    if(k>length)
+    {
+      length = k;
+    }
+  }
+  return length;
 }
 
@@ -3884 +3948 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4145 +4209 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4287 +4351 @@
 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)
+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;
+  assume(currRing != NULL && curr_weight != NULL &&
+         target_weight != NULL && G->m[0] != NULL);
+
+  int i,weight_norm,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)
+  intvec* result = new intvec(nV);
+
+  intvec* next_weight1 =MkInterRedNextWeight(curr_weight,target_weight,G);
+  //compute a random next weight vector "next_weight2"
+  while(1)
+  {
+    weight_norm = 0;
+    while(weight_norm == 0)
+    {
+
+      for(i=0; i<nV; 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=0; i<nV; 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);
+      }
+    }
+
+    if(test_w_in_ConeCC(G, next_weight22) == 1)
+    {
+      next_weight2 = MkInterRedNextWeight(next_weight22,target_weight,G);
+      if(MivAbsMax(next_weight2)>1147483647)
       {
         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];
+          (*next_weight22)[i] = (*next_weight2)[i];
         }
-        weight_norm = 1 + floor(sqrt(weight_norm));
-      }
-
-      for(i=nV-1; i>=0; i--)
-      {
-        if((*next_weight22)[i] < 0)
+        i = 0;
+        /* reduce the size of the maximal entry of the vector*/
+        while(test_w_in_ConeCC(G,next_weight22))
         {
-          (*next_weight22)[i] = 1 + (*curr_weight)[i] + floor(weight_rad*(*next_weight22)[i]/weight_norm);
+          (*next_weight2)[i] = (*next_weight22)[i];
+          i = MivAbsMaxArg(next_weight22);
+          (*next_weight22)[i] = floor(0.1*(*next_weight22)[i] + 0.5);
         }
-        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);
+      }
+      delete next_weight22;
+      break;
+    }
+  }
+  
+  // compute "usual" next weight vector
+  intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
+  ideal G_test = MwalkInitialForm(G, next_weight);
+  ideal G_test2 = MwalkInitialForm(G, next_weight2);
+
+  // compare next weights
+  if(Overflow_Error == FALSE)
+  {
     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|
+    if(G_test1->m[0] != NULL && maxlengthpoly(G_test1) < maxlengthpoly(G_test))//if(IDELEMS(G_test1) < IDELEMS(G_test))
+    {
+      if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test1))//if(IDELEMS(G_test2) < IDELEMS(G_test1))
       {
         for(i=0; i<nV; i++)
@@ -4359 +4435 @@
         }
       }
-      else // |G_test1| < |G_test|, |G_test1| < |G_test2|
+      else
       {
         for(i=0; i<nV; i++)
@@ -4365 +4441 @@
           (*result)[i] = (*next_weight1)[i];
         }
-      }
+      }    
     }
     else
     {
-      if(IDELEMS(G_test2) <= IDELEMS(G_test)) // |G_test2| <= |G_test| <= |G_test1|
+      if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))//if(IDELEMS(G_test2) < IDELEMS(G_test)) // |G_test2| < |G_test| <= |G_test1|
       {
         for(i=0; i<nV; i++)
@@ -4376 +4452 @@
         }
       }
-      else // |G_test| <= |G_test1|, |G_test| < |G_test2|
+      else
       {
         for(i=0; i<nV; i++)
@@ -4384 +4460 @@
       }
     }
-    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
+  {
+    Overflow_Error = FALSE;
+    if(G_test2->m[0] != NULL && maxlengthpoly(G_test2) < maxlengthpoly(G_test))//if(IDELEMS(G_test2) < IDELEMS(G_test))
+    {
+      for(i=1; i<nV; i++)
+      {
+        (*result)[i] = (*next_weight2)[i];
+      }
     }
     else
     {
-      delete result;
-      return next_weight2;
-    }
-  }
-}
-#endif
-
-/********************************
- * 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 randCount=0;
-  int nV = currRing->N;
-  intvec* next_weight2;
-  intvec* next_weight22 = new intvec(nV);
-  intvec* result = new intvec(nV);
-
-  //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"
-  while(1)
-  {
-    weight_norm = 0;
-    while(weight_norm == 0)
-    {
       for(i=0; i<nV; 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=0; i<nV; 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);
-      }
-    }
-    if(test_w_in_ConeCC(G, next_weight22) == 1)
-    {
-      next_weight2 = MkInterRedNextWeight(next_weight22,target_weight,G);
-      delete next_weight22;
-      break;
-    }
-  }
-  // compute "usual" next weight vector
-  intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight, G);
-  ideal G_test = MwalkInitialForm(G, next_weight);
-  ideal G_test2 = MwalkInitialForm(G, next_weight2);
-
-  // compare next weights
-  if(Overflow_Error == FALSE)
-  {
-    ideal G_test1 = MwalkInitialForm(G, next_weight1);
-    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];
-        }
-      }
-    }
-    idDelete(&G_test1);
-  }
-  else
-  {
-    Overflow_Error = FALSE;
-    if(IDELEMS(G_test2) < IDELEMS(G_test))
-    {
-      for(i=1; i<nV; i++)
-      {
-        (*result)[i] = (*next_weight2)[i];
-      }
-    }
-    else
-    {
-      for(i=0; i<nV; i++)
-      {
         (*result)[i] = (*next_weight)[i];
       }
     }
   }
+  //PrintS("\n MWalkRandomNextWeight: Ende ok!\n");
   idDelete(&G_test);
   idDelete(&G_test2);
@@ -4575 +4541 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     TargetRing = currRing;
@@ -4646 +4612 @@
     else
     {
-      rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(curr_weight));
     }
     newRing = currRing;
@@ -4755 +4721 @@
     else
     {
-      rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+      rChangeCurrRing(VMrDefault(orig_target_weight));
     }
     F1 = idrMoveR(G, newRing,currRing);
@@ -4786 +4752 @@
       else
       {
-        rChangeCurrRing(VMrDefault(orig_target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(orig_target_weight));
       }
     KSTD_Finish:
@@ -4884 +4850 @@
       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 +4880 @@
       oldRing = currRing;
 
-      /* create a new ring newRing */
+      // create a new ring newRing
        if (rParameter(currRing) != NULL)
        {
@@ -4921 +4887 @@
        else
        {
-         rChangeCurrRing(VMrDefault(curr_weight)); // Aenderung
+         rChangeCurrRing(VMrDefault(curr_weight));
        }
       newRing = currRing;
@@ -4947 +4913 @@
       else
       {
-        rChangeCurrRing(VMrDefault(curr_weight));  //Aenderung
+        rChangeCurrRing(VMrDefault(curr_weight));
       }
       newRing = currRing;
@@ -4959 +4925 @@
       M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
       delete hilb_func;
-#endif // BUCHBERGER_ALG
+#endif
       tstd = tstd + clock() - to;
 
@@ -4968 +4934 @@
 
       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 +4986 @@
       else
       {
-        rChangeCurrRing(VMrDefault(target_weight)); // Aenderung
+        rChangeCurrRing(VMrDefault(target_weight));
       }
       F1 = idrMoveR(G, newRing,currRing);
@@ -5065 +5033 @@
  * 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)
+  {
+    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;
+  //BOOLEAN endwalks = FALSE;
 #ifdef TIME_TEST
   clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
@@ -5080 +5053 @@
 #endif
   nstep=0;
-  int i,nwalk,endwalks = 0;
+  int i,nwalk;
   int nV = baseRing->N;
 
-  ideal Gomega, M, F, Gomega1, Gomega2, M1; //, F1;
+  ideal Gomega, M, F, FF, Gomega1, Gomega2, M1;
   ring newRing;
   ring XXRing = baseRing;
+  ring targetRing;
   intvec* ivNull = new intvec(nV);
   intvec* curr_weight = new intvec(nV);
   intvec* target_weight = new intvec(nV);
   intvec* exivlp = Mivlp(nV);
+/*
   intvec* tmp_weight = new intvec(nV);
   for(i=0; i<nV; i++)
   {
-    (*tmp_weight)[i] = (*target_M)[i];
-  }
+    (*tmp_weight)[i] = (*orig_M)[i];
+  }
+*/
   for(i=0; i<nV; i++)
   {
@@ -5111 +5087 @@
 #endif
   rComplete(currRing);
-#ifdef CHECK_IDEAL_MWALK
-    idString(Go,"Go");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+  if(printout > 2)
+  {
+    idString(Go,"//** Mwalk: Go");
+  }
+//#endif
+
+  if(target_M->length() == nV)
+  {
+   // define the target ring
+    targetRing = VMrDefault(target_weight);
+  }
+  else
+  {
+    targetRing = VMatrDefault(target_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);
+
 #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);
-      }
-  rChangeCurrRing(newRing);
+
   ideal G = MstdCC(idrMoveR(Go,baseRing,currRing));
-  baseRing = currRing;
+
 #ifdef TIME_TEST
   tostd = clock()-to;
 #endif
 
+  baseRing = currRing;
   nwalk = 0;
+
   while(1)
   {
     nwalk ++;
     nstep ++;
+
 #ifdef TIME_TEST
     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"
+    // 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
+    tif = tif + clock()-to;
+#endif
+
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mwalk: Gomega");
+    }
+//#endif
+
+    if(reduction == 0)
+    {
+      FF = middleOfCone(G,Gomega);
+      if( FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF);
+        goto NEXT_VECTOR;
+      } 
+    }
+
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(curr_weight) == 0)
     {
       hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
-    }
+    }   
     else
     {
@@ -5160 +5170 @@
     }
 #endif
+
     if(nwalk == 1)
     {
       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 +5187 @@
      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),lp)"
+       newRing = VMrDefault(curr_weight);
      }
      else
      {
+       //define a new ring with matrix ordering
        newRing = VMatrRefine(target_M,curr_weight);
      }
@@ -5199 +5213 @@
 #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 +5228 @@
     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);
+
     rChangeCurrRing(newRing); // change the ring to newRing
     G = idrMoveR(F,baseRing,currRing);
     idDelete(&F);
+    idSkipZeroes(G);
+
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(G, "//** Mwalk: G");
+    }
+//#endif
+
+    rChangeCurrRing(targetRing);
+    G = idrMoveR(G,newRing,currRing);
+    // test whether target cone is reached
+    if(reduction !=0 && test_w_in_ConeCC(G,curr_weight) == 1)
+    {
+      baseRing = currRing;
+      break;
+      //endwalks = TRUE;
+    }
+
+    rChangeCurrRing(newRing);
+    G = idrMoveR(G,targetRing,currRing);
     baseRing = currRing;
+
+/*
 #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 TIME_TEST
     to = clock();
 #endif
+    NEXT_VECTOR:
     intvec* next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
 #ifdef TIME_TEST
     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(target_weight,curr_weight) == 1)// || endwalks == TRUE)
+    {/*
+//#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 +5316 @@
       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");
+      }
+      PrintS("\n //** Mwalk: kStd(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);
@@ -5276 +5335 @@
       Gomega2 = idrMoveR(Gomega1, newRing,currRing);
       idDelete(&Gomega1);
+      //PrintS("\n //** Mwalk: MLifttwoIdeal");
       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 +5354 @@
       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
-  //    }
+      //PrintS("\n //**Mwalk: Interreduce");
+      //interreduce the Groebner basis <G> w.r.t. currRing
+      //G = kInterRedCC(G,NULL);
 #ifdef TIME_TEST
       tred = tred + clock() - to;
 #endif
       idSkipZeroes(G);
-      delete next_weight;
+      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--)
     {
-      (*tmp_weight)[i] = (*curr_weight)[i];
+      //(*tmp_weight)[i] = (*curr_weight)[i];
       (*curr_weight)[i] = (*next_weight)[i];
     }
@@ -5317 +5374 @@
   rChangeCurrRing(XXRing);
   ideal result = idrMoveR(G,baseRing,currRing);
+  idDelete(&Go);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
-  delete tmp_weight;
+  //delete tmp_weight;
   delete ivNull;
   delete exivlp;
@@ -5328 +5383 @@
 #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
+  }
   Set_Error(FALSE);
   Overflow_Error = FALSE;
+  //BOOLEAN endwalks = FALSE;
 #ifdef TIME_TEST
   clock_t tinput, tostd, tif=0, tstd=0, tlift=0, tred=0, tnw=0;
@@ -5354 +5411 @@
 #endif
   nstep=0;
-  int i,nwalk,endwalks = 0;
-  int nV = baseRing->N;
-
-  ideal Gomega, M, F, Gomega1, Gomega2, M1; //, F1;
+  int i,polylength,nwalk;
+  int nV = currRing->N;
+
+  ideal Gomega, M, F,FF, Gomega1, Gomega2, M1;
   ring newRing;
-  ring XXRing = baseRing;
+  ring targetRing;
+  ring baseRing = currRing;
+  ring XXRing = currRing;
   intvec* ivNull = new intvec(nV);
   intvec* curr_weight = new intvec(nV);
   intvec* target_weight = new intvec(nV);
   intvec* exivlp = Mivlp(nV);
+  intvec* next_weight= new intvec(nV);
+/*
   intvec* tmp_weight = new intvec(nV);
   for(i=0; i<nV; i++)
@@ -5369 +5430 @@
     (*tmp_weight)[i] = (*target_M)[i];
   }
+*/
   for(i=0; i<nV; i++)
   {
@@ -5385 +5447 @@
 #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(target_M->length() == nV)
+  {
+   // define the target ring
+    targetRing = VMrDefault(target_weight);
+  }
+  else
+  {
+    targetRing = VMatrDefault(target_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 +5483 @@
     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"
+    //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
+    // test whether target cone is reached
+/*    if(test_w_in_ConeCC(G,target_weight) == 1)
+    {
+      endwalks = TRUE;
+    }*/
+    if(reduction == 0)
+    {
+      
+      FF = middleOfCone(G,Gomega);
+      
+      if(FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF);
+        
+        goto NEXT_VECTOR;
+      } 
+    }
 #ifndef  BUCHBERGER_ALG
     if(isNolVector(curr_weight) == 0)
     {
       hilb_func = hFirstSeries(Gomega,NULL,NULL,curr_weight,currRing);
-    }
+    }   
     else
     {
@@ -5449 +5540 @@
      if(target_M->length() == nV)
      {
-       newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
+       newRing = VMrDefault(curr_weight); // define a new ring with ordering "(a(curr_weight),lp)
+       //newRing = VMrRefine(curr_weight,target_weight); //define a new ring with ordering "(a(curr_weight),Wp(target_weight))"
      }
      else
@@ -5473 +5565 @@
 #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 +5580 @@
     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 +5600 @@
 #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
+
+    rChangeCurrRing(targetRing);
+    G = idrMoveR(G,newRing,currRing);
+    // test whether target cone is reached
+    if(reduction !=0 && test_w_in_ConeCC(G,curr_weight) == 1)
+    {
+      baseRing = currRing;
+      break;
+    }
+
+    rChangeCurrRing(newRing);
+    G = idrMoveR(G,targetRing,currRing);
+    baseRing = currRing;
+
+
+    NEXT_VECTOR:
 #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
-    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)// || endwalks == TRUE)
+    {/*
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 0)
+      {
+        PrintS("\n//** Mrwalk: 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)
@@ -5538 +5666 @@
       Gomega1 = idrMoveR(Gomega, baseRing,currRing);
       idDelete(&Gomega);
-#ifdef CHECK_IDEAL_MWALK
-      idString(Gomega1, "Gomega");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 1)
+      {
+        idString(Gomega1, "//** Mrwalk: Gomega");
+      }
+      PrintS("\n //** Mrwalk: kStd(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,"//** Mrwalk: M");
+      }
+//#endif
       rChangeCurrRing(baseRing);
       M1 =  idrMoveR(M, newRing,currRing);
@@ -5550 +5685 @@
       Gomega2 = idrMoveR(Gomega1, newRing,currRing);
       idDelete(&Gomega1);
+      //PrintS("\n //** Mrwalk: MLifttwoIdeal");
       F = MLifttwoIdeal(Gomega2, M1, G);
-#ifdef CHECK_IDEAL_MWALK
-      idString(F,"F");
-#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(F,"//** Mrwalk: F");
+      }
+//#endif
       idDelete(&Gomega2);
       idDelete(&M1);
@@ -5565 +5704 @@
       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
-  //    }
+      //PrintS("\n //**Mrwalk: Interreduce");
+      //interreduce the Groebner basis <G> w.r.t. currRing
+      //G = kInterRedCC(G,NULL);
 #ifdef TIME_TEST
       tred = tred + clock() - to;
 #endif
       idSkipZeroes(G);
-      delete next_weight;
+      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--)
     {
-      (*tmp_weight)[i] = (*curr_weight)[i];
+      //(*tmp_weight)[i] = (*curr_weight)[i];
       (*curr_weight)[i] = (*next_weight)[i];
     }
     delete next_weight;
   }
+  baseRing = currRing;
   rChangeCurrRing(XXRing);
   ideal result = idrMoveR(G,baseRing,currRing);
   idDelete(&G);
-/*#ifdef CHECK_IDEAL_MWALK
-  pDelete(&p);
-#endif*/
-  delete tmp_weight;
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
+  //delete tmp_weight;
   delete ivNull;
   delete exivlp;
@@ -5601 +5733 @@
   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 +5882 @@
 // 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;
@@ -5766 +5904 @@
   nstep = 0;
   int i, ntwC=1, ntestw=1,  nV = currRing->N;
-  int endwalks=0;
-
-  ideal Gomega, M, F, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
+  BOOLEAN endwalks = FALSE;
+
+  ideal Gomega, M, F, FF, G, Gomega1, Gomega2, M1,F1,Eresult,ssG;
   ring newRing, oldRing, TargetRing;
   intvec* iv_M_dp;
@@ -5790 +5928 @@
   ring XXRing = currRing;
 
-
   to = clock();
-  /* perturbs the original vector */
+  // perturbs the original vector
   if(MivComp(curr_weight, iv_dp) == 1) //rOrdStr(currRing) := "dp"
   {
@@ -5809 +5946 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 1
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     G = idrMoveR(Go, XXRing,currRing);
@@ -5824 +5961 @@
   ring HelpRing = currRing;
 
-  /* perturbs the target weight vector */
+  // perturbs the target weight vector
   if(tp_deg > 1 && tp_deg <= nV)
   {
@@ -5830 +5967 @@
       DefRingPar(target_weight);
     else
-      rChangeCurrRing(VMrDefault(target_weight)); // Aenderung 2
+      rChangeCurrRing(VMrDefault(target_weight));
 
     TargetRing = currRing;
@@ -5837 +5974 @@
     {
       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);
     }
@@ -5844 +5979 @@
     {
       iv_M_lp = MivMatrixOrder(target_weight);
-      //target_weight = MPertVectorslp(ssG, iv_M_lp, tp_deg);
       target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
     }
@@ -5852 +5986 @@
     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)
   {
     nstep ++;
     to = clock();
-    /* compute an initial form ideal of <G> w.r.t. the weight vector
-       "curr_weight" */
+    // 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,"//** Mpwalk: Gomega");
+    }
+//#endif
+    if(reduction == 0 && nstep > 1)
+    {
+      // check whether weight vector is in the interior of the cone
+      while(1)
+      {
+        FF = middleOfCone(G,Gomega);
+        if(FF != NULL)
+        {
+          idDelete(&G);
+          G = idCopy(FF);
+          idDelete(&FF);
+          next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+          if(printout > 0)
+          {
+            MivString(curr_weight, target_weight, next_weight);
+          }
+        }
+        else
+        {
+          break;
+        }
+        for(i=nV-1; i>=0; i--)
+        {
+          (*curr_weight)[i] = (*next_weight)[i];
+        }
+        Gomega = MwalkInitialForm(G, curr_weight);
+        if(printout > 1)
+        {
+          idString(Gomega,"//** Mpwalk: Gomega");
+        }
+      }
+    }
 
 #ifdef ENDWALKS
-    if(endwalks == 1){
+    if(endwalks == TRUE)
+    {
       Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
       idElements(G, "G");
-      // idElements(Gomega, "Gw");
       headidString(G, "G");
-      //headidString(Gomega, "Gw");
     }
 #endif
@@ -5891 +6062 @@
       DefRingPar(curr_weight);
     else
-      rChangeCurrRing(VMrDefault(curr_weight)); //Aenderung 3
+      rChangeCurrRing(VMrDefault(curr_weight));
 
     newRing = currRing;
@@ -5897 +6068 @@
 
 #ifdef ENDWALKS
-    if(endwalks==1)
+    if(endwalks==TRUE)
     {
       Print("\n// ring r%d = %s;\n", nstep, rString(currRing));
@@ -5912 +6083 @@
     tim = clock();
     to = clock();
-    /* compute a reduced Groebner basis of <Gomega> w.r.t. "newRing" */
+    // compute a reduced Groebner basis of <Gomega> w.r.t. "newRing"
 #ifdef  BUCHBERGER_ALG
     M = MstdhomCC(Gomega1);
@@ -5918 +6089 @@
     M=kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,curr_weight);
     delete hilb_func;
-#endif // BUCHBERGER_ALG
-
-    if(endwalks == 1){
+#endif
+//#ifdef CHECK_IDEAL_MWALK
+      if(printout > 2)
+      {
+        idString(M,"//** Mpwalk: M");
+      }
+//#endif
+
+    if(endwalks == TRUE){
       xtstd = xtstd+clock()-to;
 #ifdef ENDWALKS
@@ -5930 +6107 @@
       tstd=tstd+clock()-to;
 
-    /* change the ring to oldRing */
+    // change the ring to oldRing
     rChangeCurrRing(oldRing);
     M1 =  idrMoveR(M, newRing,currRing);
     Gomega2 =  idrMoveR(Gomega1, newRing,currRing);
-
-    //if(endwalks==1)  PrintS("\n// Lifting is working:..");
 
     to=clock();
@@ -5942 +6117 @@
        Gomega is a reduced Groebner basis w.r.t. the current ring */
     F = MLifttwoIdeal(Gomega2, M1, G);
-    if(endwalks != 1)
+    if(endwalks == FALSE)
       tlift = tlift+clock()-to;
     else
       xtlift=clock()-to;
 
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 2)
+    {
+      idString(F,"//** Mpwalk: F");
+    }
+//#endif
+
     idDelete(&M1);
     idDelete(&Gomega2);
     idDelete(&G);
 
-    /* change the ring to newRing */
+    // change the ring to newRing
     rChangeCurrRing(newRing);
-    F1 = idrMoveR(F, oldRing,currRing);
-
-    //if(endwalks==1)PrintS("\n// InterRed is working now:");
+    if(reduction == 0)
+    {
+      G = idrMoveR(F,oldRing,currRing);
+    }
+    else
+    {
+      F1 = idrMoveR(F, oldRing,currRing);
+      if(printout > 2)
+      {
+        PrintS("\n //** Mpwalk: reduce the Groebner basis.\n");
+      }
+      to=clock();
+      G = kInterRedCC(F1, NULL);
+      if(endwalks == FALSE)
+        tred = tred+clock()-to;
+      else
+        xtred=clock()-to;
+      idDelete(&F1);
+    }
+    if(endwalks == TRUE)
+      break;
 
     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 */
+    // 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 > 0)
+    {
+      MivString(curr_weight, target_weight, next_weight);
+    }
+//#endif
 
     if(Overflow_Error == TRUE)
@@ -5994 +6184 @@
     }
     if(MivComp(next_weight, target_weight) == 1)
-      endwalks = 1;
+      endwalks = TRUE;
 
     for(i=nV-1; i>=0; i--)
@@ -6000 +6190 @@
 
     delete next_weight;
-  }//while
+  }//end of while-loop
 
   if(tp_deg != 1)
@@ -6014 +6204 @@
         DefRingPar(orig_target);
       else
-        rChangeCurrRing(VMrDefault(orig_target)); //Aenderung
+        rChangeCurrRing(VMrDefault(orig_target));
 
     TargetRing=currRing;
@@ -6030 +6220 @@
     if( ntestw != 1 || ntwC == 0)
     {
-      /*
-      if(ntestw != 1){
+      if(ntestw != 1 && printout >2)
+      {
         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");
-      }
-      */
+        //idElements(F1, "G");
+      }
       // LastGB is "better" than the kStd subroutine
       to=clock();
@@ -6068 +6257 @@
     Eresult = idrMoveR(G, newRing,currRing);
   }
+  si_opt_1 = save1; //set original options, e. g. option(RedSB)
   delete ivNull;
   if(tp_deg != 1)
@@ -6082 +6272 @@
              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;
+  BOOLEAN endwalks = FALSE;
+
+  ideal Gomega, M, F, FF, 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);
+        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);
+        target_weight = MPertVectors(ssG, iv_M_lp, tp_deg);
+      }
+      else
+      {
+        iv_M_lp = MivMatrixOrder(target_weight);
+        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);
+    polylength = lengthpoly(Gomega);
+//#ifdef CHECK_IDEAL_MWALK
+    if(printout > 1)
+    {
+      idString(Gomega,"//** Mprwalk: Gomega");
+    }
+//#endif
+
+    if(reduction == 0 && nstep > 1)
+    {
+      // check whether weight vector is in the interior of the cone
+      while(1)
+      {
+        FF = middleOfCone(G,Gomega);
+        if(FF != NULL)
+        {
+          idDelete(&G);
+          G = idCopy(FF);
+          idDelete(&FF);
+          next_weight = MwalkNextWeightCC(curr_weight,target_weight,G);
+          if(printout > 0)
+          {
+            MivString(curr_weight, target_weight, next_weight);
+          }
+        }
+        else
+        {
+          break;
+        }
+        for(i=nV-1; i>=0; i--)
+        {
+          (*curr_weight)[i] = (*next_weight)[i];
+        }
+        Gomega = MwalkInitialForm(G, curr_weight);
+        if(printout > 1)
+        {
+          idString(Gomega,"//** Mprwalk: Gomega");
+        }
+      }
+    }
+
+#ifdef ENDWALKS
+    if(endwalks == TRUE)
+    {
+      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 == TRUE)
+    {
+      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 == TRUE)
+    {
+      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 == FALSE)
+      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);
+    if(reduction == 0)
+    {
+      G = idrMoveR(F,oldRing,currRing);
+    }
+    else
+    {
+      F1 = idrMoveR(F, oldRing,currRing);
+      if(printout > 2)
+      {
+        PrintS("\n //** Mprwalk: reduce the Groebner basis.\n");
+      }
+      to=clock();
+      G = kInterRedCC(F1, NULL);
+      if(endwalks == FALSE)
+        tred = tred+clock()-to;
+      else
+        xtred=clock()-to;
+      idDelete(&F1);
+    }
+
+    if(endwalks == TRUE)
+      break;
+
+    to=clock();
+
+    next_weight = MkInterRedNextWeight(curr_weight,target_weight, G);
+    if(polylength > 0)
+    {
+      if(printout > 2)
+      {
+        Print("\n //**Mprwalk: there is a polynomial in Gomega with at least 3 monomials, low-dimensional facet of the cone.\n");
+      }
+      delete next_weight;
+      next_weight = MWalkRandomNextWeight(G, curr_weight, target_weight, weight_rad, op_deg);
+    }
+    tnw=tnw+clock()-to;
+//#ifdef PRINT_VECTORS
+    if(printout > 0)
+    {
+      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 = TRUE;
+
+    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 && printout > 2)
+      {
+        ivString(pert_target_vector, "tau");
+        PrintS("\n// **Mprwalk: 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)
+      {
+        if(printout > 2)
+        {
+          PrintS("\n// ** Mprwalk: Call \"std\" to compute a Groebner basis.\n");
+        }
+        eF1 = MstdCC(F1);
+        idDelete(&F1);
+      }
+      else
+      {
+        if(printout > 2)
+        {
+          PrintS("\n// **Mprwalk: Call \"LastGB\" to compute a Groebner basis.\n");
+        }
+        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 +6769 @@
  * 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 reduction, int printout)
 {
   Overflow_Error =  FALSE;
-  //Print("\n\n// Entering the %d-th recursion:", nlev);
-
+  if(printout >0)
+  {
+    Print("\n\n// Entering the %d-th recursion:", nlev);
+  }
   int i, nV = currRing->N;
   ring new_ring, testring;
   //ring extoRing;
-  ideal Gomega, Gomega1, Gomega2, F, F1, Gresult, Gresult1, G1, Gt;
+  ideal Gomega, Gomega1, Gomega2, FF, F, F1, Gresult, Gresult1, G1, Gt;
   int nwalks = 0;
   intvec* Mwlp;
@@ -6127 +6789 @@
   intvec* next_vect;
   intvec* omega2 = new intvec(nV);
-  intvec* altomega = 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 +6836 @@
     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");
+      if (MivComp(next_vect, omega2) == 1)
+      {
+        // 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);
@@ -6217 +6899 @@
         to=clock();
 
-        /* to avoid the value of Overflow_Error that occur in Mfpertvector*/
+        // to avoid the value of Overflow_Error that occur in Mfpertvector
         Overflow_Error = FALSE;
-
         next_vect = MkInterRedNextWeight(omega,omega2,G);
         xtnw=xtnw+clock()-to;
-
-#ifdef PRINT_VECTORS
+      }// end of (if MivComp(next_vect, omega2) == 1)
+
+//#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
-       computed by Buchberger algorithm and stop this recursion step*/
-    //if(test_w_in_ConeCC(G, next_vect) != 1) //e.g. Example s7, cyc6
-    if(Overflow_Error == TRUE)
+      }
+//#endif
+
+    // check whether the the computed vector is in the correct cone.
+    // If no, compute the reduced Groebner basis of an omega-homogeneous
+    // ideal with Buchberger's algorithm and stop this recursion step
+    if(Overflow_Error == TRUE || test_w_in_ConeCC(G, next_vect) != 1)  //e.g. Example s7, cyc6
     {
       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 +6933 @@
       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);
@@ -6257 +6945 @@
 
       delete omega2;
-      delete altomega;
-
-      //Print("\n// Leaving the %d-th recursion with %d steps", nlev, nwalks);
-      //Print("  ** Overflow_Error? (%d)", Overflow_Error);
+      //delete altomega;
+      if(printout > 0)
+      {
+        Print("\n//** rec_fractal_call: Overflow. Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+      }
+
       nnflow ++;
-
       Overflow_Error = FALSE;
       return (G1);
@@ -6277 +6968 @@
     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;
       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;
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Correct cone. Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+        }
+        return (Gt);
+      }
+      else
+      {
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Wrong cone. Tau doesn't stay in the correct cone.\n");
+        }
+
+#ifndef  MSTDCC_FRACTAL
+        intvec* Xtautmp;
+        if(ivtarget->length() == nV)
+        {
+          Xtautmp = Mfpertvector(Gt, MivMatrixOrder(omtmp));
+        }
+        else
+        {
+          Xtautmp = Mfpertvector(Gt, ivtarget);
+        }
+#ifdef TEST_OVERFLOW
+      if(Overflow_Error == TRUE)
+      Gt = NULL; return(Gt);
+#endif
+
+        if(MivSame(Xtau, Xtautmp) == 1)
+        {
+          if(printout > 0)
+          {
+            Print("\n//** rec_fractal_call: Updated vectors are equal to the old vectors.\n");
+          }
+          delete Xtautmp;
+          goto FRACTAL_MSTDCC;
+        }
+
+        Xtau = Xtautmp;
+        Xtautmp = NULL;
+
+        for(i=nV-1; i>=0; i--)
+          (*omega2)[i] = (*Xtau)[(nlev-1)*nV+i];
+
+        rChangeCurrRing(oRing);
+        G = idrMoveR(Gt, testring,currRing);
+
+        goto NEXT_VECTOR_FRACTAL;
+#endif
+
+      FRACTAL_MSTDCC:
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Wrong cone. Applying Buchberger's algorithm in ring = %s.\n",
+                rString(currRing));
+        }
+        to=clock();
+        G = MstdCC(Gt);
+        xtextra=xtextra+clock()-to;
+
+        oRing = currRing;
+
+        // update the original target vector w.r.t. the current GB
+        if(ivtarget->length() == nV)
+        {
+          if(MivSame(Xivinput, Xivlp) == 1)
+            if (rParameter(currRing) != NULL)
+              DefRingParlp();
+            else
+              VMrDefaultlp();
+          else
+            if (rParameter(currRing) != NULL)
+              DefRingPar(Xivinput);
+            else
+              rChangeCurrRing(VMrDefault(Xivinput));
+        }
+        else
+        {
+          rChangeCurrRing(VMatrRefine(ivtarget,Xivinput));
+        }
+        testring = currRing;
+        Gt = idrMoveR(G, oRing,currRing);
+
+        // 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);
+
+        delete omega2;
+        delete next_vect;
+        //delete altomega;
+        if(printout > 0)
+        {
+          Print("\n//** rec_fractal_call: Vectors updated. Leaving the %d-th recursion with %d steps.\n",
+              nlev, nwalks);
+          //Print(" ** Overflow_Error? (%d)", Overflow_Error);
+        }
+        if(Overflow_Error == TRUE)
+          nnflow ++;
+
+        Overflow_Error = FALSE;
+        return(G);
+      }
+    }// end of (if next_vect==nullvector)
+
+    for(i=nV-1; i>=0; i--) {
+      //(*altomega)[i] = (*omega)[i];
+      (*omega)[i] = (*next_vect)[i];
+    }
+    delete next_vect;
+
+    to=clock();
+    // Take the initial form of <G> w.r.t. omega
+    Gomega = MwalkInitialForm(G, omega);
+    xtif=xtif+clock()-to;
+    if(printout > 1)
+    {
+      idString(Gomega,"//** rec_fractal_call: Gomega");
+    }
+
+    if(reduction == 0)
+    {
+      // Check whether the intermediate weight vector lies in the interior of the cone.
+      // If so, only perform reductions. Otherwise apply Buchberger's algorithm.
+      FF = middleOfCone(G,Gomega);
+      if( FF != NULL)
+      {
+        idDelete(&G);
+        G = idCopy(FF);
+        idDelete(&FF);
+        // Compue next vector. 
+        goto NEXT_VECTOR_FRACTAL;
+      } 
+    }
+
+#ifndef  BUCHBERGER_ALG
+    if(isNolVector(omega) == 0)
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,omega,currRing);
+    else
+      hilb_func = hFirstSeries(Gomega,NULL,NULL,last_omega,currRing);
+#endif
+
+    if(ivtarget->length() == nV)
+    {
+      if (rParameter(currRing) != NULL)
+        DefRingPar(omega);
+      else
+        rChangeCurrRing(VMrDefault(omega));
+    }
+    else
+    {
+      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 == Xnlev || lengthpoly(Gomega1) == 0)
+    {
+      if(printout > 1)
+      {
+        Print("\n//** rec_fractal_call: Maximal recursion depth.\n");
+      }
+
+      to=clock();
+#ifdef  BUCHBERGER_ALG
+      Gresult = MstdhomCC(Gomega1);
+#else
+      Gresult =kStd(Gomega1,NULL,isHomog,NULL,hilb_func,0,NULL,omega);
+      delete hilb_func;
+#endif
+      xtstd=xtstd+clock()-to;
+    }
+    else
+    {
+      rChangeCurrRing(oRing);
+      Gomega1 = idrMoveR(Gomega1, oRing,currRing);
+      Gresult = rec_fractal_call(idCopy(Gomega1),nlev+1,omega,reduction,printout);
+    }
+    if(printout > 2)
+    {
+      idString(Gresult,"//** rec_fractal_call: M");
+    }
+    //convert a Groebner basis from a ring to another ring
+    new_ring = currRing;
+
+    rChangeCurrRing(oRing);
+    Gresult1 = idrMoveR(Gresult, new_ring,currRing);
+    Gomega2 = idrMoveR(Gomega1, new_ring,currRing);
+
+    to=clock();
+    // Lifting process
+    F = MLifttwoIdeal(Gomega2, Gresult1, G);
+    xtlift=xtlift+clock()-to;
+    if(printout > 2)
+    {
+      idString(F,"//** rec_fractal_call: F");
+    }
+    idDelete(&Gresult1);
+    idDelete(&Gomega2);
+    idDelete(&G);