Changeset bd7468 in git

Timestamp:

Feb 24, 2007, 4:09:51 PM (17 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', 'b324714bf5073469800caef737deba1366fbd81f')

Children:

101775c32e4f8f7cd743c23b9822bc53abca1792

Parents:

2abb041913e22b03ba7227d2705d03a49a7de82a

Message:

*greuel: new standard.lib


git-svn-id: file:///usr/local/Singular/svn/trunk@9895 2c84dea3-7e68-4137-9b89-c4e89433aadc

File:

• Singular/LIB/standard.lib (modified) (51 diffs)

Singular/LIB/standard.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
 //major revision Jan/Feb. 2007, GMG
+//groebner mit Optionen versehen
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: standard.lib,v 1.87 2007-02-04 11:37:35 Singular Exp $";
+version="$Id: standard.lib,v 1.88 2007-02-24 15:09:51 Singular Exp $";
 category="Miscellaneous";
 info="
@@ -17 +18 @@
  weightKB(stc,dd,vl)    degree dd part of a kbase wrt. some weigths
 ";
-
-// quotientList(L,...)    a list, say L, s.t. ring(L) creates a correct qring
+// qslimgb(i)             computes a standard basis with slimgb in a qring
+// hilbRing([i])          create a ring containing the homogenized i
 // par2varRing([i])       create a ring with pars to vars together with i
-// hilbRing([i])          create a ring containing the homogenized i
-// qslimgb(i)             computes a standard basis with slimgb in a qring
+// quotientList(L,...)    a list, say QL, s.t. ring(QL) creates a correct qring
+
 //////////////////////////////////////////////////////////////////////////////
 
-proc stdfglm (ideal i, list #)
+proc stdfglm (i, list #)
 "SYNTAX: @code{stdfglm (} ideal_expression @code{)} @*
          @code{stdfglm (} ideal_expression@code{,} string_expression @code{)}
 TYPE:    ideal
 PURPOSE: computes the standard basis of the ideal in the basering
-         via @code{fglm} (from the ordering given as the second argument
-         to the ordering of the basering).@*
-         If no second argument is given, \"dp\" is used.
-SEE ALSO: fglm, groebner, std, stdhilb
+         via @code{fglm} from the ordering given as the second argument
+         to the ordering of the basering. If no second argument is given,
+         \"dp\" is used. The standard basis for the given ordering (resp. for
+         \"dp\") is computed via the command groebner except if a further
+         argument \"std\" or \"slimgb\" is given in which case std resp.
+         slimgb is used.
+SEE ALSO: fglm, groebner, std, slimgb, stdhilb
 KEYWORDS: fglm
 EXAMPLE: example stdfglm; shows an example"
 {
-    //### ev. erweitern: Gewichte von aussen setzen
-    string os;
-    int s = size(#);
-    def P= basering;
-    if( s==0 or (typeof(#[1]) != "string") )
-    {
-       os = "dp(" + string( nvars(P) ) + ")";
-       if ( (find( ordstr(P), os ) != 0) and (find( ordstr(P), "a") == 0) )
-       {
-          os= "Dp";
-       }
-       else
-       {
-          os= "dp";
-       }
-    }
-    else { os = #[1]; }
-
-    list BRlist = ringlist(P);
-    int nvarP = nvars(P);
-    intvec w;                       //for ringweights of basering P
-    int k;
-    for(k=1;  k<=nvarP; k++)
-    {
-       w[k]=deg(var(k));
-    }
-
-    BRlist[3] = list();
-    if( s==0 )
-    {
-      if( w==1 )
-      {
-         BRlist[3][1]=list("dp",w);
+   if (nrows(i) > 1)
+   {
+      ERROR("first argument of 'stdfglm' must be an ideal");
+   }
+   string os;
+   int s = size(#);
+   def P= basering;
+   string algorithm;
+   int ii;
+   for( ii=1; ii<=s; ii++)
+   {
+      if ( typeof(#[ii])== "string" )
+      {
+         if ( #[ii]=="std" || #[ii]=="slimgb" )
+         {
+            algorithm =  #[ii];
+            # = delete(#,ii);
+            s = s-1;
+            ii--;
+         }
+      }
+   }
+
+   if( s > 0 && (typeof(#[1]) == "string") )
+   {
+      os = #[1];
+      ideal Qideal = ideal(P);
+      int sQ = size(Qideal);
+      int sM = size(minpoly);
+      if ( sM!=0 )
+      {
+         string mpoly = string(minpoly);
+      }
+      if (sQ!=0 )
+      {
+        execute("ring Rfglm=("+charstr(P)+"),("+varstr(P)+"),"+os+";");
+        ideal Qideal = fetch(P,Qideal);
+        qring Pfglm = groebner(Qideal,"std","slimgb");
       }
       else
       {
-         BRlist[3][1]=list("wp",w);
-      }
-      BRlist[3][2]=list("C",intvec(0));
-      def Pfglm = ring(quotientList(BRlist));
-      setring Pfglm;
+        execute("ring Pfglm=("+charstr(P)+"),("+varstr(P)+"),"+os+";");
+      }
+      if ( sM!=0 )
+      {
+        execute("minpoly="+mpoly+";");
+      }
     }
     else
     {
-       ideal Qideal = ideal(P);
-       int sQ = size(Qideal);
-       int sM = size(minpoly);
-       if ( sM!=0 )
-       {
-          string mpoly = string(minpoly);
-       }
-       if (sQ!=0 )
-       {
-         execute("ring Rfglm=("+charstr(P)+"),("+varstr(P)+"),"+os+";");
-         ideal Qideal = fetch(P,Qideal);
-         qring Pfglm = groebner(Qideal,"std","slimgb");
-       }
-       else
-       {
-          execute("ring Pfglm=("+charstr(P)+"),("+varstr(P)+"),"+os+";");
-       }
-       if ( sM!=0 )
-       {
-          execute("minpoly="+mpoly+";");
-       }
-    }
-    ideal i= fetch(P,i);
-
-    //save options:
-    int p_opt;
-    string s_opt = option();
-    if (find(s_opt, "prot"))  { p_opt = 1; }
-    intvec opt= option(get);
-
+      list BRlist = ringlist(P);
+      int nvarP = nvars(P);
+      intvec w;                       //for ringweights of basering P
+      int k;
+      for(k=1;  k <= nvarP; k++)
+      {
+        w[k]=deg(var(k));
+      }
+
+      BRlist[3] = list();
+      if( s==0 or (typeof(#[1]) != "string") )
+      {
+        if( w==1 )
+        {
+           BRlist[3][1]=list("dp",w);
+        }
+        else
+        {
+           BRlist[3][1]=list("wp",w);
+        }
+        BRlist[3][2]=list("C",intvec(0));
+        def Pfglm = ring(quotientList(BRlist));
+        setring Pfglm;
+      }
+    }
+    ideal i = fetch(P,i);
+
+    intvec opt = option(get);            //save options
     option(redSB);
-    //if(p_opt){"groebner in "+string(Pfglm);}
-    i = groebner(i,"std","slimgb");
+    if (size(algorithm) > 0)
+    {
+       i = groebner(i,algorithm);
+    }
+    else
+    {
+       i = groebner(i);
+    }
     option(set,opt);
     setring P;
@@ -119 +133 @@
 example
 { "EXAMPLE:"; echo = 2;
-   ring r=0,(x,y,z),lp;
-   ideal i=y3+x2,x2y+x2,x3-x2,z4-x2-y;
-   stdfglm(i);         //uses fglm from "dp" to "lp"
-
-   ring s = (0,x),(y,z,u,v),lp;
-// qring qs = std(y2-z3);        ### Bug in fglm mit qring
+   ring r  = 0,(x,y,z),lp;
+   ideal i = y3+x2,x2y+x2,x3-x2,z4-x2-y;
+   stdfglm(i);                   //uses fglm from "dp" (with groebner) to "lp"
+   stdfglm(i,"std");             //uses fglm from "dp" (with std) to "lp"
+
+   ring s  = (0,x),(y,z,u,v),lp;
    minpoly = x2+1;
-   ideal i = y3+x2,u2y+u2,u3-u2,z4-u2-y,v;
-   stdfglm(i,"Dp");     //uses fglm from "Dp" to "lp"
+   ideal i = u5-v4,zv-u2,zu3-v3,z2u-v2,z3-uv,yv-zu,yu-z2,yz-v,y2-u,u-xy2;
+   weight(i);
+   stdfglm(i,"(a(2,3,4,5),dp)"); //uses fglm from "(a(2,3,4,5),dp)" to "lp"
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-proc stdhilb(ideal i,list #)
+proc stdhilb(i,list #)
 "SYNTAX: @code{stdhilb (} ideal_expression @code{)} @*
+         @code{stdhilb (} module_expression @code{)} @*
          @code{stdhilb (} ideal_expression@code{,} intvec_expression @code{)}
          @code{stdhilb (} ideal_expression@code{,} list of string_expressions
                and intvec_expressin @code{)} @*
-TYPE:    ideal
-PURPOSE: Compute a Groebner basis of the ideal in the basering by using the
-         Hilbert driven Groebner basis algorithm.
+TYPE:    type of the first argument
+PURPOSE: Compute a Groebner basis of the ideal/module in the basering by
+         using the Hilbert driven Groebner basis algorithm.
          If an argument of type string @code{\"std\"} resp. @code{\"slimgb\"}
          is given, the standard basis computation uses @code{std} or
@@ -151 +167 @@
          driven algorithm.
 NOTE:    'homogeneous' means weighted homogeneous with respect to the weights
-         w[i] of the variables var(i) of the basering.
-ASSUME:  The argument of type intvec is the 1st Hilbert series as computed
-         by @code{hilb} using an intvector w with w[i]=deg(var(i)).
+         w[i] of the variables var(i) of the basering. Parameters are not
+         converted to variables.
+ASSUME:  The argument of type intvec is the 1st Hilbert series, computed
+         by @code{hilb} using an intvector w, w[i]=deg(var(i)), as third
+         argument
 SEE ALSO: stdfglm, std, slimgb, groebner
 KEYWORDS: Hilbert function
@@ -161 +179 @@
 //--------------------- save data from basering --------------------------
   def P=basering;
+  int nr = nrows(i);            //nr=1 iff i is an ideal
   ideal Qideal = ideal(P);      //defining the quotient ideal if P is a qring
   int was_qring;                //remembers if basering was a qring
@@ -192 +211 @@
 //--------------------- check the given method ---------------------------
   string method;
-  list Method;
   for (k=1; k<=size(#); k++)
   {
@@ -202 +220 @@
      {
        method = method + "," + #[k];
-       Method = Method + list(#[k]);
      }
   }
@@ -225 +242 @@
          return( std(i,hi,w) );
       }
-      if (p_opt){"stdhilb not implemented, use std in basering";}
-      //if ( neg ) // std can handle local and mixed orderings
+      if (p_opt){"//--stdhilb not implemented, use std in basering";}
+      //if ( neg )
       //{
       //  "//*** WARNING: non-positive ring weights, computation may not finish";
@@ -235 +252 @@
 //------------------------ change to hilbRing ----------------------------
 
-     list hiRi = hilbRing(i);
-     intvec W = hiRi[2];
-     def Philb = hiRi[1];      //note: Philb is no qring and the predefined
-     setring Philb;            //ideal Id(1) in Philb is homogeneous
-
+     list hiRi = hilbRing(i);  //The ground field of P and Philb coincide
+     intvec W = hiRi[2];       //Philb has an extra variable @ or @(k)
+     def Philb = hiRi[1];      //Philb is no qring and the predefined
+     setring Philb;            //ideal/module Id(1) in Philb is homogeneous
+                               //Parameters of P are not converted in Philb
 //-------- compute Hilbert function of homogenized ideal in Philb ---------
 //Philb has only 1 block. There are three cases
@@ -266 +283 @@
      if ( algorithm=="slimgb" || ( algorithm=="stdorslimgb" && char(P)==0 ) )
      {
-       intvec hi = hilb(qslimgb(Id(1)),1,W);
+        intvec hi = hilb(qslimgb(Id(1)),1,W);
      }
 
-   //------------- case where we need another intermediate ring -------------
-   //we add extra blocks for homogenizing variable @hilbRing@
-   //and for converted parameters
+   //-------------- we need another intermediate ring Phelp ----------------
+   //In Phelp we change the ordering from Philb, otherwise it coincides with
+   //Philb, that is, it has in addition to P an extra homogenizing variable
+   //with name @, resp. @(i) if @ and @(1), ..., @(i-1) are defined.
+   //Phelp has the same ordering as P on common variables. In Phelp
+   //a quotient ideal from P is added to the input
 
       list BRlist = ringlist(Philb);
@@ -297 +317 @@
       def Phelp = ring(quotientList(BRlist));
       setring Phelp;
-      ideal i = imap(Philb, Id(1));
+      def i = imap(Philb, Id(1));
       kill Philb;
 
       // compute std with Hilbert series
-      if (w ==1 )
+      if (w ==1)
       {
          if (p_opt){ "std with hilb in " + string(Phelp);}
@@ -320 +340 @@
           "dehomogenization";
       }
-      i = subst(i, @hilbRing@, 1);
+      i = subst(i, var(nvars(basering)), 1);
 
        if (p_opt)
@@ -335 +355 @@
        i = imap(Phelp,i);
        kill Phelp;
+       if( was_qring)
+       {
+         i = NF(i,std(0));
+       }
        i = simplify(i,34);
 
-       // compute reduces SB
+       // compute reduced SB
        if (find(s_opt, "redSB") > 0)
        {
          if (p_opt)
          {
-           "interreduction";
+           "//interreduction";
          }
          i=interred(i);
@@ -392 +416 @@
       }
    }
-   ideal Qideal  = RL[4];  //##Achtung, nichtkommuatativem Fall behandeln
-   if( size(Qideal) <= 1)
+   ideal Qideal  = RL[4];  //##Achtung: falls basering Nullteiler hat, kann
+                           //die SB eines Elements mehrere Elemente enthalten
+   if( size(Qideal) <= 0)
    {
       return (RL);
@@ -427 +452 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc par2varRing (list #)
-"USAGE:   par2varRing([l]); l list of ideals [default:l=empty list]
+"USAGE:   par2varRing([l]); l list of ideals/modules [default:l=empty list]
 RETURN:  list, say L, with L[1] a ring where the parameters of the
          basering have been converted to an additional last block of
-         variables all of weight 1 and ordering dp.
-         If a list l with l[i] an ideal is given, then l[i]+minpoly is
-         mapped to an ideal in L[1] with name Id(i)
+         variables, all of weight 1, and ordering dp.
+         If a list l with l[i] an ideal/module is given, then
+         l[i] + minpoly*freemodule(nrows(l[i])) is mapped to an ideal/module
+         in L[1] with name Id(i).
          If the basering has no parameters then L[1] is the basering.
 EXAMPLE: example par2varRing; shows an example"
@@ -445 +471 @@
      for( ii = 1; ii <= s; ii++)
      {
-        ideal Id(ii) = #[ii];
+        def Id(ii) = #[ii];
         export (Id(ii));
      }
@@ -455 +481 @@
    rlist[1] = parlist[1];
    poly Minpoly = minpoly;     //check for minpoly:
+   int sm = size(Minpoly);
 
    //now create new ring
-   if ( size(Minpoly) == 0 )
-   {
-      for( ii = 1; ii <= s; ii++)
-      {
-        ideal Id(ii) = #[ii];
-      }
-   }
-   else
-   {
-      if( find(option(),"prot") ){"add minpoly to input";}
-      for( ii = 1; ii <= s; ii++)
-      {
-        ideal Id(ii) = #[ii];
-        Id(ii)[ncols(Id(ii))+1]=Minpoly;
-      }
+   for( ii = 1; ii <= s; ii++)
+   {
+      def Id(ii) = #[ii];
    }
    int nvar = size(rlist[2]);
@@ -500 +515 @@
    def Ppar2var = ring(quotientList(rlist));
    setring Ppar2var;
-   for( ii = 1; ii <= s; ii++)
-   {
-      def Id(ii) = imap(P,Id(ii));
-      export (Id(ii));
+   if ( sm == 0 )
+   {
+      for( ii = 1; ii <= s; ii++)
+      {
+        def Id(ii) = imap(P,Id(ii));
+        export (Id(ii));
+      }
+   }
+   else
+   {
+      if( find(option(),"prot") ){"//add minpoly to input";}
+      poly Minpoly = imap(P,Minpoly);
+      for( ii = 1; ii <= s; ii++)
+      {
+        def Id(ii) = imap(P,Id(ii));
+        Id(ii) = Id(ii),Minpoly*freemodule(nrows(Id(ii)));
+        export (Id(ii));
+      }
    }
    list Lpar2var = Ppar2var;
@@ -516 +545 @@
    setring(P);
    Id(1);
+
+   setring R;
+   module m = x3*[1,1,1], (xyzuv-1)*[1,0,1];
+   def Q = par2varRing(m)[1]; Q;
+   setring(Q);
+   print(Id(1));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 proc hilbRing ( list # )
-"USAGE:   hilbRing([l]); l list of ideals [default:l=empty list]
+"USAGE:   hilbRing([l]); l list of ideals/modules [default:l=empty list]
 RETURN:  list, say L: L[1] is a ring and L[2] an intvec
-         L[1] is a ring whith an extra homogenizing variable
-         @hilbRing@. The monomial ordering of L[1] is 1 block dp if the
+         L[1] is a ring whith an extra homogenizing variable with name @,
+         resp. @(i) if @ and @(1), ..., @(i-1) are defined.
+         The monomial ordering of L[1] is 1 block dp if the
          weights of the variables of the basering, say R, are all 1, resp.
          wp(w,1) wehre w is the intvec of weights of the variables of R.
-         If the basering is a quotient ring P/Q, then L[1] is not a quotient
-         ring but contains the ideal @Qidealhilb@, the homogenized ideal
-         Q of P.
+         If R is a quotient ring P/Q, then L[1] is not a quotient ring but
+         contains the ideal @Qidealhilb@, the homogenized ideal Q of P.
+         (Parameters of R are not touched).
          If a list l is given with l[i] an ideal, then l[i] is
          mapped to the homogenized ideal Id(i) in L[1].
@@ -538 +574 @@
 {
    def P = basering;
-   number Minpoly = minpoly;
-  //##kann entfallen, wenn minpoly richtig gemapt wird
-
-   if( size(Minpoly) > 0 )     //remember minpoly //##
-   {
-     int is_minpoly =1;
-   }
-
    ideal Qideal = ideal(P);    //defining the quotient ideal if P is a qring
    if( size(Qideal) != 0 )
@@ -565 +593 @@
    for(k = 1; k <= s; k++)
    {
-      ideal Id(k) = #[k];
-   }
-
-    // a homogenizing variable is added
-    BRlist[2][nvarP+1] = "@hilbRing@";
+      def Id(k) = #[k];
+      int nr(k) = nrows(Id(k));
+   }
+
+    // a homogenizing variable is added:
+    // call it @, resp. @(k) if @(1),...,@(k-1) are defined
+    string homvar;
+    if ( defined(@)==0 )
+    {
+       homvar = "@";
+    }
+    else
+    {
+       k=1;
+       while( defined(@(k)) != 0 )
+       {
+          k++;
+       }
+       homvar = "@("+string(k)+")";
+    }
+    BRlist[2][nvarP+1] = homvar;
     w[nvarP +1]=1;
 
@@ -588 +632 @@
 
     //change ring and get ideal from previous ring
-    //(imap converts parameters of P automatically to variables in Phelp)
-    if( defined(is_minpoly) ) //##
-    {
-       BRlist[1][4] = ideal(0);
-    }
-
     def Philb = ring(quotientList(BRlist));
     kill BRlist;
     setring Philb;
-    if( defined(is_minpoly) ) //##
-    {
-       minpoly = imap(P,Minpoly);
-    }
     if( defined(is_qring) )
     {
-       ideal @Qidealhilb@ =  homog( imap(P,Qideal), @hilbRing@ );
+       ideal @Qidealhilb@ =  homog( imap(P,Qideal), `homvar` );
        export(@Qidealhilb@);
 
@@ -609 +643 @@
        for(k = 1; k <= s; k++)
        {  //homogenize
-          ideal Id(k) =  homog( imap(P,Id(k)), @hilbRing@ ), @Qidealhilb@ ;
+          def Id(k) =  homog( imap(P,Id(k)), `homvar` );
+              Id(k) =  Id(k),@Qidealhilb@*freemodule(nr(k)) ;
           export(Id(k));
        }
@@ -617 +652 @@
         for(k = 1; k <= s; k++)
         { //homogenize
-            ideal Id(k) =  homog( imap(P,Id(k)), @hilbRing@ );
+            def Id(k) =  homog( imap(P,Id(k)), `homvar` );
             export(Id(k));
         }
     }
-
     list Lhilb = Philb,w;
     return(Lhilb);
@@ -637 +671 @@
    qring T = std(x+y2+z3);
    ideal i = xy+xv+yz+zu+uv,xyzuv-v5;
-   def Q = hilbRing(i)[1];  Q;
+   module m = i*[0,1,1] + (xyzuv-v5)*[1,1,0];
+   def Q = hilbRing(m)[1];  Q;
    setring Q;
-   Id(1);
+   print(Id(1));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 proc qslimgb (i)
-"USAGE:   qslimgb(i); i ideal
-RETURN:  ideal, a standard basis of i computed with slimgb
+"USAGE:   qslimgb(i); i ideal or module
+RETURN:  same type as input, a standard basis of i computed with slimgb
 NOTE:    As long as slimgb does not know qrings qslimgb should be used in case
          the basering is (possibly) a quotient ring. The quotient ideal is
          added to the input and slimgb is applied.
-         ** not yet implemented for modules
 EXAMPLE: example qslimgb; shows an example"
 {
@@ -676 +710 @@
     kill BRlist;
     setring Phelp;
-    ideal iq = imap(P,i), imap(P,Qideal);
+    // module case:
+    def iq = imap(P,i);
+    iq = iq, imap(P,Qideal)*freemodule(nrows(iq));
     if (p_opt)
     {
@@ -687 +723 @@
     if (p_opt)
     {
-       "imap to original ring";
+       "//imap to original ring";
     }
     i = imap(Phelp,iq);
@@ -696 +732 @@
        if (p_opt)
        {
-         "interreduction";
+         "//interreduction";
        }
        i=interred(i);
@@ -708 +744 @@
    qring Q = std(x2-y3);
    ideal i = x+y2,xy+yz+zu+u*v,xyzu*v-1;
-   ideal j = qslimgb(i);
+   ideal j = qslimgb(i); j;
+
+   module m = [x+y2,1,0], [1,1,x2+y2+xyz];
+   print(qslimgb(m));
 }
 
@@ -732 +771 @@
            a Groebner basis is first computed with an \"easy\" ordering
            and then converted to the ordering of the basering by the
-           Hilbert driven Groebner basis computation.
+           Hilbert driven Groebner basis computation or by linear algebra.
            The actual computation of the Groebner basis can be
            specified by @code{\"std\"} or by @code{\"slimgb\"}
@@ -762 +801 @@
 //---------------------------------
 //0. Immer Aufruf von std unabhaengig von der Vorgabe:
-//   gemischte Ordnungen, extra Gewichtsvektor, Matrix Ordnungen, Moduln
+//   gemischte Ordnungen, extra Gewichtsvektor, Matrix Ordnungen
 
 //1. Keine Vorgabe: es wirkt die aktuelle Heuristk:
@@ -776 +815 @@
 //   gewaehlt (da slimgb keine Hilbertfunktion kennt, wird std verwendet).
 //   Bei slimgb im qring, wird das Quotientenideal zum Ideal addiert.
-//   Bei Angabe von std zusammen mit slimgb (aeuquivalent zur Angabe von
+//   Bei Angabe von std zusammen mit slimgb (aequivalent zur Angabe von
 //   keinem von beidem) wirkt obige Heuristik.
 
@@ -795 +834 @@
   else {ideal i=i_par; }
   kill i_par;
+
 //----------------------- save the given method ---------------------------
   string method;
@@ -803 +843 @@
      if (typeof(#[k]) == "int")
      {
-       if (defined(wait) != voice)
-       {
-         int wait = #[k];
-       }
+       int wait = #[k];
      }
      if (typeof(#[k]) == "string")
@@ -821 +858 @@
     {
         int j = 10;
-
         string bs = nameof(basering);
         link l_fork = "MPtcp:fork";
@@ -827 +863 @@
         write(l_fork, quote(system("pid")));
         int pid = read(l_fork);
-        write(l_fork, quote(groebner(eval(i))));
-//###        write(l_fork, quote(groebner(eval(i),Method)));
-//Fehlermeldung:
+//        write(l_fork, quote(groebner(eval(i))));
+        write(l_fork, quote(groebner(eval(i),eval(Method))));
+//###Fehlermeldung:
 // ***dError: undef. ringorder used
 // occured at:
@@ -935 +971 @@
     || ( find(ordstr_P,"M") > 0 )
     || ( find(ordstr_P,"a") > 0 )
-    || ( nrows(i)>1 )    //module case, not yet handled by slimgb
-    || ( neg>0 ) )       //***fuer Moduln slimgb zulassen, wenn implementiert
+    || ( neg>0 ) )
   {
     if (p_opt) { "std in basering"; }
-    //if ( neg > 0 ) // std can handle local and mixed orderings
-    //{
-    //  "*** WARNING: some weights are negative, computation may not finish";
-    //}
-    i = std(i);
-    return(i);
+    return(std(i));
   }
 
 //now we have:
-//ideal, global ordering, no matrix ordering, no extra weight vector
+//ideal or module, global ordering, no matrix ordering, no extra weight vector
 //The interesting cases start now.
 
@@ -1012 +1042 @@
   //define direct:
   if ( (order=="simple" && (size(method)==0 )) ||
-       (order=="simple" && (method==",par2var" && npars_P==0 )) ||
+        (order=="simple" && (method==",par2var" && npars_P==0 )) ||
          (conversion=="no" && partovar=="no" &&
            (algorithm=="std" || algorithm=="slimgb" ||
@@ -1040 +1070 @@
      if ( algorithm=="std" || (algorithm=="stdorslimgb" && char(P)>0) )
      {
-       if (p_opt) { "std in " + string(P); }
-       return(std(i));
+           if (p_opt) { "std in " + string(P); }
+           i = std(i);
+           return(i);
      }
      if ( algorithm=="slimgb" || (algorithm=="stdorslimgb" && char(P)==0) )
      {
-       return(qslimgb(i));
+           i = qslimgb(i);
+           return(i);
      }
   }
@@ -1056 +1088 @@
 //Note thar "par2var" is not a default strategy, it must be explicitely
 //given in order to be performed.
-//## TODO: fglm has still to be implemented
 
 //------------ case where no parameters are made to variables  -------------
@@ -1067 +1098 @@
      if ( conversion=="fglm" )
      {
-       return (stdfglm(i));
+       if ( algorithm=="std" || (algorithm=="stdorslimgb" && char(P)>0) )
+       {
+         return (stdfglm(i,"std"));
+       }
+       if ( algorithm=="slimgb" || (algorithm=="stdorslimgb" && char(P)==0) )
+       {
+         return (stdfglm(i,"slimgb"));
+       }
      }
-     if ( algorithm=="std" || (algorithm=="stdorslimgb" && char(P)>0) )
-     {
-       return (stdhilb(i,"std"));
-     }
-     if ( algorithm=="slimgb" || (algorithm=="stdorslimgb" && char(P)==0) )
-     {
-       return (stdhilb(i,"slimgb"));
+     else
+     {
+       if ( algorithm=="std" || (algorithm=="stdorslimgb" && char(P)>0) )
+       {
+         return (stdhilb(i,"std"));
+       }
+       if ( algorithm=="slimgb" || (algorithm=="stdorslimgb" && char(P)==0) )
+       {
+         return (stdhilb(i,"slimgb"));
+       }
      }
    }
@@ -1086 +1127 @@
       // reset options
       option(none);
-      // turn on options prot, mem, intStrategy if previously set
+      // turn on options prot, mem, redSB, intStrategy if previously set
       if ( find(s_opt, "prot") )
       { option(prot); }
       if ( find(s_opt, "mem") )
       { option(mem); }
+      if ( find(s_opt, "redSB") )
+      { option(redSB); }
       if ( find(s_opt, "intStrategy") )
       { option(intStrategy); }
@@ -1105 +1148 @@
       def Phelp = par2varRing(i)[1];   //minpoly is mapped with i
       setring Phelp;
-      ideal i = Id(1);
+      def i = Id(1);
       is_homog = homog(i);
 
@@ -1134 +1177 @@
        if (p_opt)
        {
-         "simplification";
+         "//simplification";
        }
 
@@ -1144 +1187 @@
        }
 
-       ideal Li = lead(i);
+       def Li = lead(i);
        setring P;
-       ideal Li = imap(Phelp,Li);
+       def Li = imap(Phelp,Li);
        Li = simplify(Li,32);
        intvec vi;
@@ -1167 +1210 @@
        if (p_opt)
        {
-         "imap to original ring";
+         "//imap to original ring";
        }
        i = imap(Phelp,i);
@@ -1179 +1222 @@
          if (p_opt)
          {
-           "interreduction";
+           "//interreduction";
          }
          i=interred(i);
@@ -1205 +1248 @@
   groebner(i,"fglm");          //computes a reduced standard basis
 
-  if (system("with","MP")) {groebner(i,0);}
+  if (system("with","MP")) {groebner(i,10,"std");}
   defined(Standard::groebner_error);
   option(set,opt);
@@ -2035 +2078 @@
 
 /*
+Versuche:
 ///////////////////////////////////////////////////////////////////////////////
 proc downsizeSB (I, list #)
@@ -2066 +2110 @@
      else
      {
-        ERROR("2nd argument must be an intvec");
+        ERROR("// 2nd argument must be an intvec");
      }
    }
@@ -2301 +2345 @@
 
 */
+