Index: Singular/LIB/normal.lib
===================================================================
--- Singular/LIB/normal.lib	(revision 4e18c51925ab32021341e7172545db0b399b0eab)
+++ Singular/LIB/normal.lib	(revision 676724024fe6f74b1903efa35331a0271eaaf678)
@@ -1,4 +1,4 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: normal.lib,v 1.34 2001-02-22 09:25:01 lossen Exp $";
+version="$Id: normal.lib,v 1.35 2001-03-19 22:57:16 greuel Exp $";
 category="Commutative Algebra";
 info="
@@ -71,9 +71,10 @@
 
 proc HomJJ (list Li)
-"USAGE:   HomJJ (Li);  Li = list: ideal SBid, ideal id, ideal J, poly p
+"USAGE:   HomJJ (Li); Li list: ideal SBid, ideal id, ideal J, poly p, int count
 ASSUME:  R    = P/id,  P = basering, a polynomial ring, id an ideal of P,
 @*       SBid = standard basis of id,
 @*       J    = ideal of P containing the polynomial p,
 @*       p    = nonzero divisor of R
+@*       count controls printlevel during recursive call
 COMPUTE: Endomorphism ring End_R(J)=Hom_R(J,J) with its ring structure as
          affine ring, together with the canonical map R --> Hom_R(J,J),
@@ -92,8 +93,12 @@
 //---------- initialisation ---------------------------------------------------
 
-   int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y;
+   int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y,count;
    intvec rw,rw1;
    list L;
-   y = printlevel-voice+2;  // y=printlevel (default: y=0)
+   if(size(Li)>=5)
+   {
+     count = Li[5];
+   }
+   y = printlevel-voice+count;  
  def P = basering;
    ideal SBid, id, J = Li[1], Li[2], Li[3];
@@ -147,5 +152,6 @@
    { "// the module p*Hom(J,J) = p*J:J, p a non-zerodivisor";
       "// p"; p;
-      "// f=p*J:J";f;
+      "// f=p*J:J";
+      if( y>=2 ) { f; }      
    }
    f2 = std(p);
@@ -187,18 +193,16 @@
       attrib(endid,"isCompleteIntersection",0);
       attrib(endid,"isRad",0);
-//      export endid;
-//      export endphi;
-//      L = newR1;
       L=lastRing;
       L = insert(L,1,1);
-      dbprint(y,"// case R = Hom(J,J)");
       if(y>=1)
       {
-         "//   R=Hom(J,J)";
+         "// case R = Hom(J,J), we are ready with this component";
          "   ";
-         lastRing;
+       if( y>=2 ) 
+       {
+        lastRing;
          "   ";
          "//   the new ideal";
-         endid;
+         if( y>=2 ) { endid; } 
          "   ";
          "//   the old ring";
@@ -218,4 +222,5 @@
          pause();
          newline;
+       }
       }
       setring P;
@@ -225,6 +230,8 @@
    {
       "// R is not equal to Hom(J,J), we have to try again";
-      pause();
-      newline;
+    if( y>=2 )
+    {  pause();
+       newline;
+    }    
    }
 //---------- Hom(J,J) != R: create new ring and map from old ring -------------
@@ -279,6 +286,9 @@
       "//   the linear relations";
       " ";
-      Lin;
-      "   ";
+      if( y>=2 )
+      {  Lin;      
+         pause();
+         "";
+      }
    }
    for (ii=2; ii<=q; ii++ )
@@ -293,8 +303,11 @@
    {
       "//   the quadratic relations";
-      "   ";
-      interred(Quad);
-      pause();
-      newline;
+        if( y>=2 )
+      {      
+          "   ";
+         interred(Quad);
+         pause();
+         newline;
+      }
    }
    Q = Lin+Quad;
@@ -329,5 +342,9 @@
    {
       "//   the new ring after reduction of the number of variables";
-      "   ";
+      show(lastRing);
+      pause(); "
+      ";
+    if(y >=2)
+    {
       lastRing;
       "   ";
@@ -352,4 +369,5 @@
       pause();
       newline;
+    }
    }
    L = lastRing;
@@ -391,8 +409,11 @@
 @end format
 NOTE:    to use the i-th ring type: def R=nor[i]; setring R;.
-@*       Increasing printlevel displays more comments (default: printlevel=0)
-@*       Not implemented for local or mixed orderings.
+@*       Not implemented for local or mixed orderings and quotient rings.
 @*       If the input ideal i is weighted homogeneous a weighted ordering may
          be used (qhweight(i); computes weights).
+@*       printlevel = 1: count normalization loops (default: printlevel=0)
+@*       printlevel > 1: protocoll of normalization steps
+@*       printlevel > 2: protocoll of all normalization steps, pauses
+@*       printlevel > 3: display some (>4 all) intermediate results, pauses
 EXAMPLE: example normal; shows an example
 "
@@ -452,5 +473,6 @@
       if(y>=1)
       {
-         "// we have ",size(prim),"equidimensional components";
+        "";
+         "// we have ",size(prim),"equidimensional component(s)";
       }
    }
@@ -465,14 +487,15 @@
          else
          {
-            prim=minAssPrimes(id);
+            prim=minAssGTZ(id);
          }
       }
       else
       {
-         prim=minAssPrimes(id);
+         prim=minAssGTZ(id);
       }
       if(y>=1)
       {
-         "// we have ",size(prim),"irreducible components";
+         "";
+         "// we have ",size(prim),"irreducible component(s)";
       }
    }
@@ -481,5 +504,6 @@
       if(y>=1)
       {
-         "// we are in loop ",i;
+         "";
+         "// BEGIN with equidimensional/irreducible component",i;
       }
       attrib(prim[i],"isCohenMacaulay",0);
@@ -508,5 +532,5 @@
              {attrib(prim[i],"isIsolatedSingularity",1); }
       }
-      keepresult=normalizationPrimes(prim[i],maxideal(1));
+      keepresult=normalizationPrimes(prim[i],maxideal(1),0);
       for(j=1;j<=size(keepresult);j++)
       {
@@ -518,5 +542,5 @@
 // 'normal' created a list of "+sr+" ring(s).
 // To see the rings, type (if the name of your list is nor):
-     show( nor);
+     show(nor);
 // To access the 1-st ring and map (similar for the others), type:
      def R = nor[1]; setring R;  norid; normap;
@@ -540,21 +564,28 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-static proc normalizationPrimes(ideal i,ideal ihp, list #)
-"USAGE:   normalizationPrimes(i,ihp[,si]);  i prime ideal, ihp map
-         (partial normalization), si SB of singular locus
+static proc normalizationPrimes(ideal i,ideal ihp, int count, list #)
+"USAGE:   normalizationPrimes(i,ihp[,si,countt]);  i prime ideal, ihp map
+         (partial normalization), si ideal of singular locus, 
+         count = integer to count the number of normalization loops
 RETURN:  a list of one ring L=R, in  R are two ideals
-         S,M such that R/M is the normalization
+         S,M such that R/M is the normalization of original basering
          S is a standardbasis of M
 NOTE:    to use the ring: def r=L[1];setring r;
-         printlevel >= voice+1: display comments (default: printlevel=0)
+         printlevel = 1: count normalization loops (default: printlevel=0)
+         printlevel > 1: protocoll of normalization steps
+         printlevel > 2: protocoll of all normalization steps, pauses
+         printlevel > 3: display some (>4 all) intermediate results, pauses
 EXAMPLE: example normalizationPrimes; shows an example
 "
 {
-   int y = printlevel-voice+2;  // y=printlevel (default: y=0)
-
-   if(y>=1)
-   {
-     "";
-     "// START a normalization loop with the ideal";  "";
+   count = count+1;   
+   int y = printlevel-voice+count+1;  // y=printlevel (default: y=0)
+   if(y>=0)
+   {
+     "// START normalization LOOP ",count;
+   }
+   if( y>=3)
+   {
+     "// with ideal";  "";
      i;  "";
      basering;  "";
@@ -562,4 +593,5 @@
      newline;
    }
+
 
    def BAS=basering;
@@ -588,9 +620,10 @@
    if(y>=1)
    {
-     "// SB-computation of the input ideal";
-   }
-
-   list SM=mstd(i);                //here the work starts
-   int dimSM =  dim(SM[1]);        //dimension of variety to normalize
+   "// SB-computation of ideal of size",size(i),"in ring with",nvars(basering),"variables";
+   }
+// -------------- SB-computation of the input ideal ----------------------
+   list SM=mstd(i);                //here the work starts, SM[1] a SB of i
+                                   //SM[2] a smaller set of generators of i
+   int dimSM =  dim(SM[1]);        //dimension of i, V(i)=variety to normalize
   // Case: Get an ideal containing a unit
    if( dimSM == -1)
@@ -620,5 +653,5 @@
    }
 
-   if(size(#)>0)
+   if(size(#)>0)                   //ideal of sing locus is given in #[1]
    {
       list JM=mstd(#[1]);
@@ -629,4 +662,5 @@
    }
 
+// -------- transfer attributes from ideal i to SM[2], SM = mstd(i) --------
    if(attrib(i,"isPrim")==1)
    {
@@ -678,5 +712,8 @@
    }
 
-   //the smooth case
+//************* case 0: check and prepare special cases ****************
+//no computation for the normalization in case 0
+
+//-------------------------- the smooth case ----------------------------
    if(size(#)>0)
    {
@@ -702,6 +739,9 @@
      }
    }
-
-   //the zero-dimensional case
+   // recall: SM = mstd(i), i = ideal to start with in normaliztion loop
+   //         JM = mstd(#[1]), #[1]= ideal of singular locus of i
+   //              #[1] is given after the first normalization loop
+
+//---------------- the homogeneous zero-dimensional case ----------------
    if((dim(SM[1])==0)&&(homog(SM[2])==1))
    {
@@ -725,7 +765,6 @@
    }
 
-   //the one-dimensional case
-   //in this case it is a line because
-   //it is irreducible and homogeneous
+//------------- the homogeneous one-dimensional case -------------------
+//in this case i defines a line because it is irreducible and homogeneous
    if((dim(SM[1])==1)&&(attrib(SM[2],"isPrim")==1)
         &&(homog(SM[2])==1))
@@ -749,6 +788,5 @@
       return(result);
    }
-
-   //the higher dimensional case
+//----------------------- the higher dimensional case ----------------------
    //we test first of all CohenMacaulay and
    //complete intersection
@@ -766,28 +804,28 @@
 
    //compute the singular locus+lower dimensional components
-   if(((attrib(SM[2],"isIsolatedSingularity")==0)||(homog(SM[2])==0))
-        &&(size(#)==0))
-   {
-/*
-write (":a normal-fehler" ,
-         "basering:",string(basering),"nvars:", nvars(basering),
-       "dim(SM[1]):",dim(SM[1]),"ncols(jacob(SM[2]))",ncols(jacob(SM[2])),
-       "SM:", SM);
-
-     pause();
-*/
+
+//------- case: not(isolated singularity and homogeneous) -------------------
+   if((attrib(SM[2],"isIsolatedSingularity")==0) && (size(#)==0))
+   {
+//---------- computation of ideal of singular locus -------------------------
       J=minor(jacob(SM[2]),nvars(basering)-dim(SM[1]));
       //ti=timer;
       if(y >=1 )
       {
-         "// SB of singular locus will be computed";
-      }
-      ideal sin=J+SM[2];
-
-    //kills the embeded components
-
+         "// SB of singular locus will be computed ";
+         if(y >=2 )
+         {
+           "//in ring:";
+           show(basering);
+         }
+      }
+      
+      J = simplify(J,16);  //this makes ist for huge J much faster
+      ideal sin=J,SM[2]; 
       list JM=mstd(sin);
-      //JM[1] SB os singular locus, JM[2]=minbasis of singular locus
-      //SM[1] SB of irreducible component, SM[2] minbasis
+      
+      //JM[1] SB of singular locus, JM[2] minbasis of singular locus
+      //SM[1] SB of ideal in normalisation loop, SM[2] minbasis
+
       if(y>=1)
       {
@@ -817,5 +855,5 @@
          return(result);
       }
-      if(dim(JM[1])==0)
+      if(dim(JM[1])==0 && (homog(SM[2])==1))
       {
          attrib(SM[2],"isIsolatedSingularity",1);
@@ -826,14 +864,23 @@
       }
    }
-   else
+   
+//------------ case: isolated singularity and homogeneous -----------------
+   if(attrib(SM[2],"isIsolatedSingularity")==1)   
    {
      if(size(#)==0)
      {
-        list JM=maxideal(1),maxideal(1);
-
+        if(defined(JM)==voice)
+        {  JM=maxideal(1),maxideal(1);
+        }
+        else
+        {  list JM=maxideal(1),maxideal(1);
+        
+        }
         attrib(JM[1],"isSB",1);
-        attrib(SM[2],"isRegInCodim2",1);
      }
    }
+
+//------------ case: Cohen Macaulay and regular in codim 2 ----------------- 
+//in this case we are ready, the ring is normal  
    if((attrib(SM[2],"isRegInCodim2")==1)&&(attrib(SM[2],"isCohenMacaulay")==1))
    {
@@ -856,15 +903,28 @@
       return(result);
    }
-   //if it is an isolated singularity things are easier
+
+//************* case 1: isolated singularity and homogeneous ****************
+
+   // recall: SM = mstd(i), i = ideal to start with in normaliztion loop
+   //         JM = mstd(#[1]), #[1]= ideal of singular locus of i
+   //              #[1] is given after the first normalization loop
+   //if SM is an isolated singularity and homogeneous, we know that this 
+   //persists in the following normalization loops and things are easier
+   //since the radical of the singular locus is the maximal ideal
    //JM ideal of singular locus, SM ideal of variety
-   if((dim(JM[1])==0)&&(homog(SM[2])==1))            //isolated sing. case
-   {
-      attrib(SM[2],"isIsolatedSingularity",1);
+
+   if(attrib(SM[2],"isIsolatedSingularity")==1)
+   {
+      if(y>=1)
+      {
+         "// CASE 1: unique isolated singularity at 0";
+         "// radial of singular locus is the maximal ideal";
+      }
       ideal SL=simplify(reduce(maxideal(1),SM[1]),2);
-           //vars not contained in ideal
+      //SL = vars not contained in ideal
       ideal Ann=quotient(SM[2],SL[1]);
-      ideal qAnn=simplify(reduce(Ann,SM[1]),2);
-
+      ideal qAnn=simplify(reduce(Ann,SM[1]),2);     
       //qAnn=0 ==> the first var(=SL[1]) not contained in SM is a nzd of R/SM
+  //--------------- case: a nonzero-divisor was found ---------------
       if(size(qAnn)==0)
       {
@@ -872,27 +932,32 @@
          {
             "";
+            "//   a nonzero-divisor was found";
             "//   the ideal rad(J):";
             "";
             maxideal(1);
             newline;
+            "// TEST for normality: R=Hom(J,J)?";
+            "";
          }
-         //again test for normality
-         //Hom(I,R)=R
+    //test for normality:
+         //?spaeter: test for normality, Hom(I,R)==R?
          list RR;
-         RR=SM[1],SM[2],maxideal(1),SL[1];
-         ti=timer;
-         RR=HomJJ(RR,y);
-         if(RR[2]==0)
+         RR=SM[1],SM[2],maxideal(1),SL[1],count;
+         //  ti=timer;
+         RR=HomJJ(RR);
+         //  timer-ti;
+         if(RR[2]==0) 
+    //the ring is not normal, start a new normalization loop
          {
             def newR=RR[1];
             setring newR;
             map psi=BAS,endphi;
-         //   ti=timer;
-            list tluser=normalizationPrimes(endid,psi(ihp));
-
-        //    timer-ti;
+         //  ti=timer;
+            list tluser=normalizationPrimes(endid,psi(ihp),count);
+         //  timer-ti;
             setring BAS;
             return(tluser);
          }
+    //the ring is normal, prepare output and go home
          MB=SM[2];
          execute("ring newR7="+charstr(basering)+",("+varstr(basering)+"),("
@@ -903,12 +968,10 @@
          export normap;
          result=newR7;
-         // the following 2 lines don't work : nor is not defined
-         //def R = nor[1]; setring R;     //make the 1-st ring the basering
-         //norid; normap;                 //data of the normalization)
          setring BAS;
          return(result);
 
        }
-      //Now the case where qAnn!=0, i.e.SL[1] is a zero divisor of R/SM
+  //--------------- case: a zero-divisor was found ---------------
+      //Now the case where qAnn!=0, i.e.SL[1] is a zero-divisor of R/SM
       //and we have found a splitting: id and id1
       //id=qAnn+SM[2] defines components of R/SM in the complement of V(SL[1])
@@ -917,4 +980,15 @@
        else
        {
+         if(y>=0)
+         {
+            "//   a zero-divisor was found, we have SPLITTING of ideals";
+           if(y >=2 )
+           {
+             "// in ring:";
+             show(basering);
+            }
+            "";
+         }
+         
           ideal id=qAnn+SM[2];
 
@@ -926,5 +1000,9 @@
           attrib(id,"isEquidimensional",0);
 
-          keepresult1=normalizationPrimes(id,ihp);
+          if(y>=0)
+          {
+    "//   start a normalization loop with 1st split ideal (size",size(id),"in",nvars(basering),"vars)";
+          }
+          keepresult1=normalizationPrimes(id,ihp,count);
           ideal id1=quotient(SM[2],Ann)+SM[2];
 //          evtl. qAnn statt Ann nehmen
@@ -938,5 +1016,9 @@
           attrib(id1,"isEquidimensional",0);
 
-          keepresult2=normalizationPrimes(id1,ihp);
+          if(y>=0)
+          {
+              "//   start a normalization loop with 2nd split ideal (size",size(id),"in",nvars(basering),"vars)";
+          }
+          keepresult2=normalizationPrimes(id1,ihp,count);
 
           for(lauf=1;lauf<=size(keepresult2);lauf++)
@@ -948,44 +1030,72 @@
    }
 
-   //test for non-normality
-   //Hom(I,I)<>R
-   //we can use Hom(I,I) to continue
+//********** case 2: no unique isolated singularity at 0 *************
+
+   //in this case the radical must be computed
+   // recall: SM = mstd(i), i = ideal to start with in normaliztion loop
+   //         JM = mstd(#[1]), #[1]= ideal of singular locus of i
+   //              #[1] is given after the first normalization loop
+   //test for normality:  Hom(J,J)=R
+   //test for non-normality: Hom(J,J)!=R, we can use Hom(J,J) to continue
+
+      if(y>=1)
+      {
+         "// CASE 2: no unique isolated singularity";
+         "// radical has to be computed";
+      }
 
    ideal SL=simplify(reduce(JM[2],SM[1]),2);
+   //SL = elements of ideal of singular locus not contained in ideal i
    ideal Ann=quotient(SM[2],SL[1]);
    ideal qAnn=simplify(reduce(Ann,SM[1]),2);
-
+   //qAnn=0 ==> SL[1] is a nonzero-divisor of R/SM
+
+  //--------------- case: a nonzero-divisor was found ---------------
    if(size(qAnn)==0)
    {
       list RR;
       list RS;
-      //now we have to compute the radical
+    //now we have to compute the radical
       if(y>=1)
       {
-         "// radical computation of singular locus";
-      }
-
-      //J=radical(SM[2]+ideal(SL[1]));   //JM[2] contains SM[2]+ideal(SL[1])
-      J=radical(JM[2]);   //the singular locus
+        "";
+         "//   a nonzero-divisor was found";
+         "//   radical computation of ideal of singular locus";
+      }
+      
+    //-------------- computation of the radical J --------------------
+    //We have at least two possibilities:
+    //J=radical(JM[2]), the radical of the full singular locus, or
+    //J=radical(SM[2]+ideal(SL[1])), JM[2] contains SM[2]+ideal(SL[1])
+      //the first is usually better!
+
       if(y>=1)
       {
-        "//   radical is equal to:";"";
-        J;
+        "// compute radical J of ideal of singular locus";"";
+      }
+
+      J=radical(JM[2]);
+      // alternativ:   J=radical(SM[2]+ideal(SL[1])); 
+
+      if(y>=2)
+      {
+          "// the radical is equal to:";        
+          J;
+          newline;
+      }
+      if(y>=1)
+      {        
+        "// TEST for normality: R=Hom(J,J)?";
         "";
       }
 
-      JM=J,J;
-
+      JM=J,J;              //J = new ideal for singular locus
       //evtl. fuer SL[1] anderen Nichtnullteiler aus J waehlen
-      RR=SM[1],SM[2],JM[2],SL[1];
-
-      //   evtl eine geeignete Potenz von JM?
-     if(y>=1)
-     {
-        "// compute Hom(rad(J),rad(J))";
-     }
-
-     RS=HomJJ(RR,y);
-
+
+    //test for normality:
+      RR=SM[1],SM[2],JM[2],SL[1],count;
+      RS=HomJJ(RR);
+      
+    //--- the ring is normal, prepare output and go home
       if(RS[2]==1)
       {
@@ -1001,4 +1111,6 @@
          return(lastR);
       }
+
+    //--- the ring is not normal, start a new normalization loop       
       int n=nvars(basering);
       ideal MJ=JM[2];
@@ -1009,9 +1121,16 @@
       map psi=BAS,endphi;
       list tluser=
-             normalizationPrimes(endid,psi(ihp),simplify(psi(MJ)+endid,4));
+           normalizationPrimes(endid,psi(ihp),count,simplify(psi(MJ)+endid,4));
       setring BAS;
       return(tluser);
    }
-    // A component with singular locus the whole component found
+  //--------------- case: a zero-divisor was found ---------------
+  //Now the case where qAnn!=0, i.e.SL[1] is a zero-divisor of R/SM
+  //and we have found a splitting: id and id1
+  //id=qAnn+SM[2] defines components of R/SM in the complement of V(SL[1])
+  //id1 defines components of R/SM in the complement of V(id)
+      //?????instead of id1 we can take SL[1]+Ann+SM[2]???????????
+
+   // A component with singular locus the whole component found:
    if( Ann == 1)
    {
@@ -1035,4 +1154,5 @@
          return(result);
    }
+   // The general case with splitting of ring, i.e. qAnn!=0
    else
    {
@@ -1041,7 +1161,8 @@
       execute("ring newR1="+charstr(basering)+",("+varstr(basering)+"),("
                       +ordstr(basering)+");");
-      if(y>=1)
-      {
-         "// zero-divisor found";
+      if(y>=0)
+      {
+            "//   a zero-divisor was found, we have SPLITTING of ideals";
+            "";
       }
       ideal vid=fetch(BAS,new1);
@@ -1061,5 +1182,10 @@
       attrib(vid,"isCompleteIntersection",0);
 
-      keepresult1=normalizationPrimes(vid,ihp);
+      if(y>=0)
+      {
+            "// start a normalization loop with 1st split ideal (size",size(vid),"in",nvars(basering),"vars)";
+      }
+
+      keepresult1=normalizationPrimes(vid,ihp,count);
 
       setring BAS;
@@ -1085,5 +1211,10 @@
       attrib(vid,"isCompleteIntersection",0);
 
-      keepresult2=normalizationPrimes(vid,ihp);
+      if(y>=0)
+      {
+            "// start a normalization loop with 2nd split ideal (size",size(vid),"in",nvars(basering),"vars)";
+      }
+
+      keepresult2=normalizationPrimes(vid,ihp,count);
 
       setring BAS;
@@ -1109,5 +1240,5 @@
    b6c+bc6+a2b4e-3ab2c2de+c4d2e-a3cde2-abd3e2+bce5;
 
-   list pr=normalizationPrimes(i);
+   list pr=normalizationPrimes(i,maxideal(1),1);
    def r1=pr[1];
    setring r1;
@@ -1216,7 +1347,17 @@
 /////////////////////////////////////////////////////////////////////////////
 /*
+Aenderungen:
+1. normal kommentiert, bei Berechnung de singulaeren Ortes ein simplify(J,16)
+eingefuehrt, um bei riesigen Minorenzahlen, das Ideal zu verkleinern (bis 
+Faktor 10 Beschleunigung). 
+Protokoll mit printlevel so gesteuert, dass es bei rekursivem Aufruf korrekt 
+arbeitet.
+list nor = normal(i);     //mit equidim Zerlegung
+list nor = normal(i,1);   //mit prim Zerlegung
+Zeiten au sony_pumuckel (P2, 500)
                            Examples:
 LIB"normal.lib";
-//Huneke
+//1. Huneke, 1 Komponente
+//prim: 2 sec equidim:1sec
 ring qr=31991,(a,b,c,d,e),dp;
 ideal i=
@@ -1231,5 +1372,5 @@
 
 
-//Vasconcelos (dauert laenger: 60 sec)
+//2. Vasconcelos (dauert laenger: 83 sec auf sony_pumuckel)
 ring r=32003,(x,y,z,w,t),dp;
 ideal i=
@@ -1238,4 +1379,90 @@
 xw3+z3t+ywt2,
 y2w4-xy2z2t-w3t3;
+
+//2a. Vasconcelos verkleinert
+//prim:2Komp, 2 Ringe, 16 sec (manchmal lange, haengt am Faktorisierer)
+//equidim: 1 Komp, 7 loops, 2 ringe, 12sec
+ring r=32003,(x,y,z,w,t),dp;
+ideal i=
+x+zw,
+y3+xwt,
+xw3+z3t+ywt2;
+
+//3. GM1
+// irreducible, 13 normalization loops, 1 Ring 
+//2sec mit prim, 1 sec mit equidim
+ring r=32003,(x,y,z,u),dp;
+ideal i = x2+y3,z2+u3,y2+z3;
+
+//3a. GM1
+ring r=32003,(x,y),dp;
+ideal i = intersect(y3+x2,y2+x3);  // beide 0 sec
+ideal i = intersect(y3+x2,y2+x3,y2+x2+x3);
+//prim 0sec,
+//equidim sehr lange (Relationen in HomJJ zu gross)
+
+//4. GM2
+//i nicht reduziert, equidim bricht ab (0 sec)
+//prim: 11 irred comp, 11 loops, (1sec)
+ring r=32003,(x,y,z,u),dp;
+ideal i = x2+y3,z2+u3,y2+z3,x2+z3;
+
+//5. GM3,  radical von GM2
+//prim: 11 irred comp, 11 loops, 11 Ringe, (1sec)
+//equidim: 1 equidim comp, 1 loop, 1 Ring, (0sec)
+ring r=32003,(x,y,z,u),dp;
+ideal i =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y;
+
+//GM4
+//equidim: 2 equidim comp, 3 Ringe, (0sec);
+//prim: 3 Komp, (0sec)
+ring r=32003,(x,y,z,u),dp;
+ideal i1 = x2+y3,u,z;
+ideal i2 = u2+z3,x,y;
+ideal i3 = x2+y2+z2+u4;
+ideal i = intersect(i1,i2,i3);
+
+//GM4a  Hier dauert prim laenger! (## facstd)
+//equidim: 3 equidim Komp, 4 Ringe(0sec)
+//prim 13 Komp (63 sec), wegen facstd 
+//##ev minAssGTZ(i,1) verwenden (ohne facstd, ist noch fehlerhaft)
+ring r=32003,(x,y,z,u),dp;
+ideal i1 = x2+y3,u,z;
+ideal i2 = u2+z3,x,y;
+ideal i3 = x2+y2+z2+u4;
+ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y;
+ideal i = intersect(i1,i2,i3,i4);
+
+//GM5
+//equidim: 4 Komp,0sec, prim 13 Komp, 1sec
+ring r=32003,(x,y,z,u,v),dp;
+ideal i1 = x2+y3,v;                            //2dim
+ideal i2 = u2+z3,x,y;                          //3dim
+ideal i3 = x2+y2+z2+u4;                        //4dim
+ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y; //1dim
+ideal i = intersect(i1,i2,i3,i4);
+
+//cyclic 5
+//equidim: 1 Komp 0sec, prim: 20 Komp, 3 sec
+ring r=32003,(x,y,z,u,v),dp;
+ideal i = 
+x+y+z+u+v,
+xy+yz+zu+xv+uv,
+xyz+yzu+xyv+xuv+zuv,
+xyzu+xyzv+xyuv+xzuv+yzuv,
+xyzuv-1;
+
+// cyclic 5 hat Normalisierung (1 embim weniger)
+///equidim: 1 Komp 0sec, prim: 20 Komp, 2 sec
+ring r=32003,(x,y,z,u),dp;
+ideal i = 
+x2+xz-yz+2xu+yu+u2,
+xy2-xyz+y2z-y2u+xzu+yzu+z2u-xu2-2yu2+zu2-u3,
+xyz2+xyzu+y2zu-xz2u+yz2u-z3u-xyu2-xzu2-2z2u2+xu3+yu3-zu3+u4,
+2xyzu2+y2zu2+2yz2u2-xyu3-2xzu3-yzu3-z2u3+xu4+yu4-2zu4+u5-1;
+
+//cyclic(6)
+//equidim: 1Komp in 5 vars 1sec
+//prim: 90 (!) Ringe, 12 sec
 
 //Theo1
@@ -1284,7 +1511,10 @@
 ad;
 
-//Beispiel, wo vorher Primaerzerlegung schneller (2 sec,sonst 860 sec)
+//Sturmfels, wo vorher Prim schneller (2 sec,sonst 860 sec)
 //ist CM
-//Sturmfels
+//prim: 15 loops, 15 Komp, 1 sec, 
+//equidim:15 Ringe, 93 sec mit simplify(J,16), 
+//ohne simlify(J,16) 860sec?, 
+//andere simplify sind z.T. viel langsamer
 ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
 ideal i=
@@ -1317,7 +1547,13 @@
 tuy-bvz;
 
-//dauert laenger ohne Primaerzerlegung vorher (1 sec gegen
 //Horrocks:
-ring r=32003,(a,b,c,d,e,f),dp;
+//CHAR 32003:mit prim 1 sec, equidim: 115 sec, beide 6 Ringe 
+//           Singulaere Ort hat zu Beginn > 106 000 Erzeuger!!
+//char 31991: prim 1sec, 8 Ringe, equidim: 25 Ringe(!), 162 sec, 
+//            nicht reduziert!
+//            Singulaere Ort hat zu Beginn > 28 000 Erzeuger!!
+//            i=radical(i) -> 8 Ringe, 1sec (radical <1 sec)
+//Horrocks:
+ring r=31991,(a,b,c,d,e,f),dp;
 ideal i=
 adef-16000be2f+16001cef2,
@@ -1356,6 +1592,5 @@
 
 
-ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
-
+ring r=32003,(b,s,t,u,v,w,x,y,z),dp;   //3sec
 ideal k=
 wy-vz,
@@ -1367,5 +1602,6 @@
 ideal i=mstd(intersect(j,k))[2];
 
-//22
+//22,
+// neu, prim: 3 sec, equidim 1 sec, je 4 Ringe
 ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
 ideal i=
@@ -1377,10 +1613,7 @@
 
 
-//riemenschneider
-//33
-//normal+primary 3
-//primary 9
-//radical 1
-//minAssPrimes 2
+//riemenschneider, 5 Komponenten
+//33(alte Zeiten), normal+primary 3, primary 9, radical 1, minAssGTZ; 2
+//neu: prim 0sec, equi 1 sec, je 5 Ringe
 ring r=32000,(p,q,s,t,u,v,w,x,y,z),wp(1,1,1,1,1,1,2,1,1,1);
 ideal i=
@@ -1398,5 +1631,5 @@
 
 ring r=0,(u,v,w,x,y,z),wp(1,1,1,3,2,1);
-ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2;
+ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2;   //0sec
 */
 
