Changeset 858cae in git

Timestamp:

Apr 8, 2011, 8:51:59 PM (13 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

2272157187c82cb5bd15a8c9b7faff7e3b064132

Parents:

1c4a19588a624228427528fb3b86f2eb66646188

Message:

fix format

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

Location:

Singular/LIB

Files:

• bfun.lib (modified) (3 diffs)
• freegb.lib (modified) (6 diffs)
• resjung.lib (modified) (34 diffs)
• sagbi.lib (modified) (17 diffs)

Singular/LIB/bfun.lib

@@ -319 +319 @@
       if (remembercoeffs <> 0)
       {
-        j = 0;
-        k = 0;
-        intvec posNonZero;
-        for (i=1; i<=sI; i++)
-        {
-          if (I[i] == 0)
+        j = 0;
+        k = 0;
+        intvec posNonZero;
+        for (i=1; i<=sI; i++)
+        {
+          if (I[i] == 0)
           {
             j++;
@@ -331 +331 @@
             M[j] = gen(i);
           }
-          else
-          {
-            k++;
-            M[k+sZeros] = gen(lJ[2][k]);
-            posNonZero = posNonZero,i;
-          }
-        }
-        posNonZero = posNonZero[2..nrows(posNonZero)];
-        posNonZero = posNonZero[lJ[2]];
-        for (i=1; i<=size(lJ[1]); i++)
-        {
-          M[i+sZeros] = gen(posNonZero[i]);
-        }
-        kill posNonZero;
+          else
+          {
+            k++;
+            M[k+sZeros] = gen(lJ[2][k]);
+             posNonZero = posNonZero,i;
+          }
+        }
+         posNonZero = posNonZero[2..nrows(posNonZero)];
+         posNonZero = posNonZero[lJ[2]];
+         for (i=1; i<=size(lJ[1]); i++)
+         {
+           M[i+sZeros] = gen(posNonZero[i]);
+         }
+        kill posNonZero;
       }
       else
@@ -403 +403 @@
           if (lm == lmJ[j])
           {
-            dbprint(ppl-1,"// reducing " + string(redpoly));
+            dbprint(ppl-1,"// reducing " + string(redpoly));
             dbprint(ppl-1,"//  with " + string(J[j]));
             c = leadcoef(redpoly)/leadcoef(J[j]);

Singular/LIB/freegb.lib

@@ -2565 +2565 @@
 PURPOSE: compute the inhomogeneous Serre's relations associated to A in given
 @*       variable names
-ASSUME: three ideals in the input are of the same sizes and contain merely 
+ASSUME: three ideals in the input are of the same sizes and contain merely
 @* variables which are interpreted as follows: N resp. P stand for negative
 @* resp. positive roots, C stand for Cartan elements. d is the degree bound for
@@ -3175 +3175 @@
 RETURN: poly
 PURPOSE: computation of the normalform of p with respect to G
-ASSUME: p is a Letterplace polynomial, G is a set Letterplace polynomials, 
+ASSUME: p is a Letterplace polynomial, G is a set Letterplace polynomials,
 being a Letterplace Groebner basis (no check for this will be done)
 NOTE: Strategy: take the smallest monomial wrt ordering for reduction
@@ -3235 +3235 @@
  }
  for (j = 1; j <= d; j++)
-  {l=(j-1)*n+1; k= j*n; 
+  {l=(j-1)*n+1; k= j*n;
    w = I[l..k];
    if (w==intvec(0)){w = I[1..(l-1)]; return(w);}//if a zero block is found there are only zero blocks left,
@@ -3344 +3344 @@
   {s = dShiftDiv(V, L[i])[1];
    if (s <> -1)
-   {p = lpReduce(p,G[i],s); 
+   {p = lpReduce(p,G[i],s);
     p = lpNormalForm1(p,G,L);
     break;
@@ -3371 +3371 @@
   if (bla == 0) {lv = cq[1..i*n]; cq = cq[(i*n+1)..(d*n)]; break;}
  }
- 
+
  d = size(cq)/n;
  for (i = 1; i<= d; i++)
@@ -3451 +3451 @@
    else {l = l[(n+1)..(n*d)]; d = d-1;}
  }
- 
+
  while (1 <= d)
   {for (j = 1; j <= n; j++)

Singular/LIB/resjung.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: jung.lib,v 1.0 2011/27/03 10:32:00 Singular Exp $";
+version="$Id$";
 category="Commutative Algebra";
 info="
 LIBRARY:  jung.lib      Resolution of surface singularities (Desingularization)
                            Algorithm of Jung
-AUTHOR:  Philipp Renner,   philipp_renner@web.de  
+AUTHOR:  Philipp Renner,   philipp_renner@web.de
 
 PROCEDURES:
- jungresolve(J[,is_noeth])  computes a resolution (!not a strong one) of the 
+ jungresolve(J[,is_noeth])  computes a resolution (!not a strong one) of the
                             surface given by the ideal J using Jungs Method,
  jungnormal(J[,is_noeth])   computes a representation of J such that all it's
@@ -26 +26 @@
 //Main procedure
 //-----------------------------------------------------------------------------------------
- 
-proc jungfib(ideal id, list #) 
+
+proc jungfib(ideal id, list #)
 "USAGE:  jungfib(J[,is_noeth]);
 @*       J = ideal
@@ -33 +33 @@
 ASSUME:  J  = two dimensional ideal
 RETURN:  a list l of rings
-         l[i] is a ring containing two Ideals: QIdeal and BMap. 
-         BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
+         l[i] is a ring containing two Ideals: QIdeal and BMap.
+         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
          V(QIdeal) has only quasi-ordinary singularities.
          If is_noeth=1 the algorithm assumes J is in noether position with respect to
-         the last two variables. As a default or if is_noeth = 0 the algorithm computes 
+         the last two variables. As a default or if is_noeth = 0 the algorithm computes
          a coordinate change such that J is in noether position.
          NOTE: since the noether position algorithm is randomized the performance
@@ -56 +56 @@
   I = radical(id);
   def A = basering;
-  int n = nvars(A);                            
+  int n = nvars(A);
   if(deg(NF(1,groebner(slocus(id)))) == -1){
     list result;
@@ -68 +68 @@
   if(char(A) <> 0){ERROR("only works for characterisitc 0");}  //dummy check
   if(dim(I)<> 2){ERROR("dimension is unequal 2");}  //dummy check
-//Noether Normalization 
+//Noether Normalization
   if(noeth == 0){
     if(n==3){
@@ -85 +85 @@
         }
         map phi = A,NoetherPos;
-        kill i,pos,NoetherPos; 
-      }
-    }
-    else{ 
+        kill i,pos,NoetherPos;
+      }
+    }
+    else{
       map phi = A,NoetherPosition(I);
     }
@@ -97 +97 @@
     map phi = A,maxideal(1);
   }
-  kill I;  
-//Critical Locus 
+  kill I;
+//Critical Locus
   def C2 = branchlocus(NoetherN);
   setring C2;
@@ -122 +122 @@
     return(result);
   }
-   
-//dim of critical locus is 1, so compute embedded resolution of the discriminant curve 
+
+//dim of critical locus is 1, so compute embedded resolution of the discriminant curve
   list embresolvee = embresolve(clocus);
-  
+
 //build the fibreproduct
   setring A;
@@ -157 +157 @@
 ASSUME:  J  = two dimensional ideal
 RETURN:  a list l of rings
-         l[i] is a ring containing two Ideals: QIdeal and BMap. 
-         BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
+         l[i] is a ring containing two Ideals: QIdeal and BMap.
+         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
          V(QIdeal) has only singularities of Hizebuch-Jung type.
          If is_noeth=1 the algorithm assumes J is in noether position with respect to
-         the last two variables. As a default or if is_noeth = 0 the algorithm computes 
+         the last two variables. As a default or if is_noeth = 0 the algorithm computes
          a coordinate change such that J is in noether position.
          NOTE: since the noether position algorithm is randomized the performance
@@ -225 +225 @@
 ASSUME:  J  = two dimensional ideal
 RETURN:  a list l of rings
-         l[i] is a ring containing two Ideals: QIdeal and BMap. 
-         BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
-         V(QIdeal) is smooth. For this the algorithm computes first with 
+         l[i] is a ring containing two Ideals: QIdeal and BMap.
+         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
+         V(QIdeal) is smooth. For this the algorithm computes first with
          jungnormal a representation of V(J) with Hirzebruch-Jung singularities
          and then it uses Villamayor's algorithm to resolve these singularities
          If is_noeth=1 the algorithm assumes J is in noether position with respect to
-         the last two variables. As a default or if is_noeth = 0 the algorithm computes 
+         the last two variables. As a default or if is_noeth = 0 the algorithm computes
          a coordinate change such that J is in noether position.
          NOTE: since the noether position algorithm is randomized the performance
@@ -284 +284 @@
   }
   return(result);
-}    
+}
 example{
     "EXAMPLE:";echo = 2;
@@ -305 +305 @@
 //Critical locus for the Weierstrass map induced by the noether normalization
 //---------------------------------------------------------------------------------------
-static proc branchlocus(ideal id)      
+static proc branchlocus(ideal id)
 {
 //"USAGE:  branchlocus(ideal J);
 //       J = ideal
 //ASSUME:  J  = two dimensional ideal in noether position with respect of
-//         the last two variables 
+//         the last two variables
 //RETURN:  A ring containing the ideal clocus respresenting the criticallocus
 // of the projection V(J)-->C^2 on the last two coordinates
@@ -324 +324 @@
       lowdim = intersect(lowdim,radical(l[j]));
     }
-  } 
+  }
   kill k;
   lowdim = radical(lowdim);
-  ideal I = radical(l[size(l)]);  
+  ideal I = radical(l[size(l)]);
   poly product=1;
-  kill l;                             
+  kill l;
   for(int i=1; i < n-1; i++){ //elimination of all variables exept var(i),var(n-1),var(n)
     intvec v;
@@ -349 +349 @@
     ringl[3]=ll;
     kill l,ll;
-    def R = ring(ringl); //now x_j > x_i > x_n-1 > x_n forall j <> i,n-1,n 
+    def R = ring(ringl); //now x_j > x_i > x_n-1 > x_n forall j <> i,n-1,n
     setring R;
     ideal J = groebner(fetch(A,I));//this eliminates the variables
     setring A;
-    ideal J = fetch(R,J);   
+    ideal J = fetch(R,J);
     attrib(J,"isPrincipal",0);
     if(size(J)==1){
@@ -380 +380 @@
       setring A;
     }
-    product = product*resultant(J[index],diff(J[index],var(i)),var(i)); 
+    product = product*resultant(J[index],diff(J[index],var(i)),var(i));
     //Product of the discriminants, which lies in C2
     kill index,J,v;
@@ -405 +405 @@
     def R = embresolve[i];
     setring R;
-    list temp = ringlist(A); 
-    //data for the new ring which is, if A=K[x_1,..,x_n] and 
+    list temp = ringlist(A);
+    //data for the new ring which is, if A=K[x_1,..,x_n] and
     //R=K[y_1,..,y_m], K[x_1,..,x_n-2,y_1,..,y_m]
     for(int j = 1; j<= nvars(R);j++){
@@ -418 +418 @@
     int m = size(J);
     def R2 = ring(temp);
-    kill temp; 
+    kill temp;
     setring R2;
     ideal Temp=0;              //defines map from R to R2 which is the inclusion
@@ -432 +432 @@
     FibPMI= FibPMI+ideal(f(J));
     map FibMap = A,FibPMI;
-    kill f,FibPMI;  
+    kill f,FibPMI;
     ideal TotalT = groebner(FibMap(NoetherN));
     ideal QIdeal = TotalT;
@@ -450 +450 @@
 //-------------------------------------------------------------------------------
 
-static proc embresolve(ideal C) 
+static proc embresolve(ideal C)
 "USAGE:  embresolve(ideal C);
 @*       C = ideal
-ASSUME:  C  = ideal of plane curve 
+ASSUME:  C  = ideal of plane curve
 RETURN:  a list l of rings
          l[i] is a ring containing a basic object BO, the result of the
-         resolution. Whereas the algorithm does not resolve normal 
+         resolution. Whereas the algorithm does not resolve normal
          crossings of V(C)
 EXAMPLE: example embresolve shows an example
@@ -464 +464 @@
   attrib(J,"iswholeRing",1);
   list primdec = equidim(C);
-  if(size(primdec)==2){   
-  //zero dimensional components of the discrimiant curve are smooth 
+  if(size(primdec)==2){
+  //zero dimensional components of the discrimiant curve are smooth
   //an cross normally so they can be ignored in the resolution process
     ideal Lowdim = radical(primdec[1]);
@@ -478 +478 @@
   list result = resolve2(BO);
   if(defined(Lowdim)){
-    for(int i = 1;i<=size(result);i++){  
+    for(int i = 1;i<=size(result);i++){
     //had zero dimensional components which I add now to the end result
       def RingforEmbeddedResolution = result[i];
-      setring RingforEmbeddedResolution; 
+      setring RingforEmbeddedResolution;
       map f = R2,BO[5];
       BO[2]=BO[2]*f(Lowdim);
@@ -492 +492 @@
 {
   "EXAMPLE:";echo=2;
-  //The following curve is the critical locus of the projection z2-x3-y3 
+  //The following curve is the critical locus of the projection z2-x3-y3
   //onto y,z-coordinates.
   ring R = 0,(y,z),dp;
@@ -506 +506 @@
 
 static proc resolve2(list BO){
-//computes an embedded resolution for the basic object BO and returns 
+//computes an embedded resolution for the basic object BO and returns
 //a list of rings with BO
   def H = basering;
@@ -515 +515 @@
   result[1]=H;
   attrib(result[1],"isResolved",0);    //has only simple normal crossings
-  attrib(result[1],"smoothC",0);       //has smooth components 
+  attrib(result[1],"smoothC",0);       //has smooth components
   int safety=0;                        //number of runs restricted to 30
   while(1){
@@ -525 +525 @@
         def R = result[j];
         setring R;
-        if(attrib(result[j],"smoothC")==0){     
+        if(attrib(result[j],"smoothC")==0){
         //has possibly singular components so choose a singular point and blow up
           list primdecPC = primdecGTZ(BO[2]);
@@ -540 +540 @@
               if(defined(blowup)){kill blowup;}
               list blowup = blowUpBO(BO,primdecSL[index][2],3);
-              //if it has a rational singularity blow it up else choose 
+              //if it has a rational singularity blow it up else choose
               //some arbitary singular point
-              if(attrib(primdecSL[1],"isRational")==0){  
-              //if we blow up a non rational singularity the exeptional divisors 
+              if(attrib(primdecSL[1],"isRational")==0){
+              //if we blow up a non rational singularity the exeptional divisors
               //are reduzible so we need to separate them
                 for(int k=1;k<=size(blowup);k++){
@@ -591 +591 @@
           kill i,primdecPC;
           j=p;
-          break; 
+          break;
         }
         else{ //if it has smooth components determine all the intersection
@@ -692 +692 @@
     list L;
     intvec v = 1,1,1;
-    L[1] = "lp";     
+    L[1] = "lp";
     L[2] = v;
     kill v;
@@ -716 +716 @@
       if(defined(k)){kill k;}
       for(int k = 2;k<=3;k++){  //checks whether f is monic in var(i)
-        if(v[k] <> 0 || v[1] == 0){ 
+        if(v[k] <> 0 || v[1] == 0){
           attrib(v,"isMonic",0);
           j++;
@@ -739 +739 @@
 
 ////copied from resolve.lib/////////////////
-static proc normalCrossing(ideal J,list E,ideal V)        
+static proc normalCrossing(ideal J,list E,ideal V)
 "Internal procedure - no help and no example available
 "
@@ -745 +745 @@
    int i,d,j;
    int n=nvars(basering);
-   list E1,E2;                   
+   list E1,E2;
    ideal K,M,Estd;
    intvec v,w;
 
-   for(i=1;i<=size(E);i++)  
+   for(i=1;i<=size(E);i++)
    {
       Estd=std(E[i]+J);
@@ -758 +758 @@
    }
    E=E1;
-   for(i=1;i<=size(E);i++)   
+   for(i=1;i<=size(E);i++)
    {
       v=i;
@@ -764 +764 @@
    }
    list ll;
-   int re=1;         
-
-   while((size(E1)>0)&&(re==1))   
+   int re=1;
+
+   while((size(E1)>0)&&(re==1))
    {
-      K=E1[1][1];                 
-      v=E1[1][2];                 
+      K=E1[1][1];
+      v=E1[1][2];
       attrib(K,"isSB",1);
       E1=delete(E1,1);
-      d=n-dim(K);                
-      M=minor(jacob(K),d)+K;     
-      if(deg(std(M+V)[1])>0)     
+      d=n-dim(K);
+      M=minor(jacob(K),d)+K;
+      if(deg(std(M+V)[1])>0)
       {
          re=0;
@@ -781 +781 @@
       for(i=1;i<=size(E);i++)
       {
-         for(j=1;j<=size(v);j++){if(v[j]==i){break;}}  
-         if(j<=size(v)){if(v[j]==i){i++;continue;}}    
-         Estd=std(K+E[i]);                             
+         for(j=1;j<=size(v);j++){if(v[j]==i){break;}}
+         if(j<=size(v)){if(v[j]==i){i++;continue;}}
+         Estd=std(K+E[i]);
          w=v;
          if(deg(Estd[1])==0){i++;continue;}
-         if(d==n-dim(Estd))                            
+         if(d==n-dim(Estd))
          {
             if(deg(std(Estd+V)[1])>0)

Singular/LIB/sagbi.lib

@@ -15 +15 @@
 
 REFERENCES:
-Ana Bravo: Some Facts About Canonical Subalgebra Bases, 
+Ana Bravo: Some Facts About Canonical Subalgebra Bases,
 MSRI Publications  51, p. 247-254
 
@@ -137 +137 @@
    */
   int ppl = printlevel-voice+3; //variable for additional printlevel-dependend information
-  dbprint(ppl,"//Spoly-1- initialisation and precomputation");  
+  dbprint(ppl,"//Spoly-1- initialisation and precomputation");
   def br=basering;
   ideal varsBasering=maxideal(1);
@@ -169 +169 @@
   }
   //--------------- calculate kernel of Phi depending on method choosen ---------------
-  dbprint(ppl,"//Spoly-2- Groebner basis computation"); 
+  dbprint(ppl,"//Spoly-2- Groebner basis computation");
   attrib(kernOld,"isSB",1);
   ideal kern=stdKernPhi(kernNew,kernOld,leadTermsAlgebra,method);
-  dbprint(ppl-2,"//Spoly-2-1- ideal kern",kern);        
+  dbprint(ppl-2,"//Spoly-2-1- ideal kern",kern);
   //-------------------------- calulate algebraic relations -----------------------
-  dbprint(ppl,"//Spoly-3- computing new algebraic relations");  
+  dbprint(ppl,"//Spoly-3- computing new algebraic relations");
   ideal algebraicRelations=nselect(kern,1..nvars(br));
   attrib(algebraicRelationsOld,"isSB",1);
@@ -201 +201 @@
    */
   int ppl = printlevel-voice+3; //variable for additional printlevel-dependend information
-  dbprint(ppl,"//Spoly-1- initialisation and precomputation");  
+  dbprint(ppl,"//Spoly-1- initialisation and precomputation");
   def br=basering;
   int m=ncols(algebra);
@@ -241 +241 @@
   ideal algebraicRelations=toric_ideal(A,"ect");
   //Suitable substitution
-        dbprint(ppl,"//Spoly-3- substitutions");        
+        dbprint(ppl,"//Spoly-3- substitutions");
   ideal leadCoefficients=fetch(br,leadCoefficients);
   for (i=1; i<=m; i++)
@@ -250 +250 @@
     }
   }
-        dbprint(ppl-2,"//Spoly-3-1- algebraic relations",algebraicRelations);   
+        dbprint(ppl-2,"//Spoly-3-1- algebraic relations",algebraicRelations);
   export algebraicRelations;
   return(rNew);
@@ -268 +268 @@
    * algebraicDependence causes this procedure to be called with parRed<>0. The only difference when parRed<>0
    * is that the reduction algorithms returns the non-zero constants it attains (instead of just returning zero as the
-         * correct remainder), as they will be expressions in parameters for an algebraic dependence.
+         * correct remainder), as they will be expressions in parameters for an algebraic dependence.
    */
   int ppl = printlevel-voice+3; //variable for additional printlevel-dependend information
-  dbprint(ppl,"//Red-1- initialisation and precomputation");    
+  dbprint(ppl,"//Red-1- initialisation and precomputation");
   def br=basering;
   int numVarsBasering=nvars(br);
@@ -279 +279 @@
   if (numVarsBasering==nvars(r))
   {
-                dbprint(ppl-1,"//Red-1-1- Groebner basis computation");
+                dbprint(ppl-1,"//Red-1-1- Groebner basis computation");
     /* Case that ring r is the same ring as the basering. Using proc extendRing,
      * stdKernPhi
@@ -315 +315 @@
   for (i=1; i<=ncols(F);i++)
   {
-                dbprint(ppl-1,"//Red-2-"+string(i)+"- starting with new polynomial");
-                dbprint(ppl-2,"//Red-2-"+string(i)+"-1- Polynomial before reduction",F[i]);
+                dbprint(ppl-1,"//Red-2-"+string(i)+"- starting with new polynomial");
+                dbprint(ppl-2,"//Red-2-"+string(i)+"-1- Polynomial before reduction",F[i]);
     normalform=0;
     while (F[i]!=0)
@@ -325 +325 @@
       //K is always contained in the subalgebra,
       //thus the remainder is zero in this case
-        if (parRed) 
-        { 
-                                //If parRed<>0 save non-zero constants the reduction algorithms attains.
-                                        break; 
-                                }
-        else 
-        { 
-                                        F[i]=0; 
-                                        break; 
-                                }
+        if (parRed)
+        {
+                                //If parRed<>0 save non-zero constants the reduction algorithms attains.
+                                        break;
+                                }
+        else
+        {
+                                        F[i]=0;
+                                        break;
+                                }
       }
       //note: as the ordering in br and r might not be compatible
@@ -423 +423 @@
  *   and iterations specifies the
  *   number of iterations. A degree boundary is not used here.
- * When this method is called via the procedures sagbi and sagbiPart the integer parRed 
- * will always be zero. Only the procedure algebraicDependence calls this procedure with 
- * parRed<>0. The only difference when parRed<>0 is that the reduction algorithms returns 
- * the non-zero constants it attains (instead of just returning zero as the correct 
- * remainder), as they will be expressions in parameters for an algebraic dependence. 
+ * When this method is called via the procedures sagbi and sagbiPart the integer parRed
+ * will always be zero. Only the procedure algebraicDependence calls this procedure with
+ * parRed<>0. The only difference when parRed<>0 is that the reduction algorithms returns
+ * the non-zero constants it attains (instead of just returning zero as the correct
+ * remainder), as they will be expressions in parameters for an algebraic dependence.
  * These constants are saved in the ideal reducedParameters.
  */
 {
   int ppl = printlevel-voice+3; //variable for additional printlevel-dependend information
-  dbprint(ppl,"// -0- initialisation and precomputation");      
+  dbprint(ppl,"// -0- initialisation and precomputation");
   def br=basering;
   int i=1;
@@ -874 +874 @@
 RETURN: ring
 ASSUME: basering is not a qring
-PURPOSE: Returns a ring containing the ideal @code{algDep}, which contains possibly 
-@*              some algebraic dependencies of the elements of I obtained through @code{it}
-@*              iterations of the SAGBI construction algorithms. See the example on how 
-@*              to access these objects. 
+PURPOSE: Returns a ring containing the ideal @code{algDep}, which contains possibly
+@*                 some algebraic dependencies of the elements of I obtained through @code{it}
+@*                 iterations of the SAGBI construction algorithms. See the example on how
+@*                 to access these objects.
 EXAMPLE: example algebraicDependence; shows an example"
 {
-        assumeQring();
-        int ppl = printlevel-voice+3; //variable for additional printlevel-dependend information
-  dbprint(ppl,"//AlgDep-1- initialisation and precomputation"); 
+        assumeQring();
+        int ppl = printlevel-voice+3; //variable for additional printlevel-dependend information
+  dbprint(ppl,"//AlgDep-1- initialisation and precomputation");
   def br=basering;
   int i;
   I=simplify(I,2); //avoid that I contains zeros
 
-        //Create two polynomial rings, which both are extensions of the current basering.
+        //Create two polynomial rings, which both are extensions of the current basering.
   //The first ring will contain the additional paramteres @c(1),...,@c(m), the second one
   //will contain the additional variables @c(1),...,@c(m), where m=ncols(I).
@@ -953 +953 @@
   //         }
 
-        //Compute a partial SAGBI basis of the algebra generated by I[1]-@c(1),...,I[m]-@c(m),
+        //Compute a partial SAGBI basis of the algebra generated by I[1]-@c(1),...,I[m]-@c(m),
   //where the @c(n) are parameters
   ideal I=fetch(br,I);
@@ -961 +961 @@
     algebra[i]=I[i]-par(i);
   }
-  dbprint(ppl,"//AlgDep-2- call of SAGBI construction algorithm");      
+  dbprint(ppl,"//AlgDep-2- call of SAGBI construction algorithm");
   algebra=sagbiConstruction(algebra, iterations,0,0,1);
-  dbprint(ppl,"//AlgDep-3- postprocessing of results"); 
+  dbprint(ppl,"//AlgDep-3- postprocessing of results");
   int j=1;
   //If K[x_1,...,x_n] was the basering, then algebra is in K(@c(1),...,@c(m))[x_1,...x_n]. We intersect
@@ -985 +985 @@
   for (i=1; i<=ncols(algDep); i++)
   {
-                if(leadmonom(algDep[i])==1) 
-                {
-                                algDep[i]=0;
-                }
-        }
-        algDep=simplify(algDep,2);
+                if(leadmonom(algDep[i])==1)
+                {
+                                algDep[i]=0;
+                }
+        }
+        algDep=simplify(algDep,2);
   export algDep,algebra;
   setring br;
@@ -1018 +1018 @@
   /* performs subalgebra interreduction of a set of subalgebra generators */
   int ppl = printlevel-voice+3; //variable for additional printlevel-dependend information
-  dbprint(ppl,"//Interred-1- starting interreduction"); 
+  dbprint(ppl,"//Interred-1- starting interreduction");
   ideal J,B;
   int i,j,k;
@@ -1031 +1031 @@
   }
   I=simplify(I,2);
-  dbprint(ppl,"//Interred-2- interreduction completed");        
+  dbprint(ppl,"//Interred-2- interreduction completed");
   return(I);
 }