Changeset 0b1671 in git

Timestamp:

Nov 8, 2023, 2:38:58 PM (6 months ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')

Children:

f21133bf9dde91dd3c42804f81af23a8aa6e30ba

Parents:

1dc25627122bccd9eebfcd84f1fb60000b4f25a3

Message:

format

Location:

Singular/LIB

Files:

• integralbasis.lib (modified) (74 diffs)
• normal.lib (modified) (20 diffs)

Singular/LIB/integralbasis.lib

@@ -2 +2 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
-version="version integralbasis.lib 4.3.1.0 Jul_2022 "; // $Id$
+version="version integralbasis.lib 4.3.2.10 Nov_2023 "; // $Id$
 category="Commutative Algebra";
 info="
@@ -54 +54 @@
         (Default option for normal algorithm.)@*
         Options for hensel algorithm:@*
-        - \"opti\" -> The integral basis for the branches are merged 
+        - \"opti\" -> The integral basis for the branches are merged
         using a combinatorial approach. (Default option.)@*
         - \"noOpti\" -> the integral basis for the different branches
@@ -619 +619 @@
     dbprint(dbg, "----Component: ");
     if(dbg>=1){compo;}
-  
+
     norOut = intBasisComp(f, compType, compo, algorithm, locBasis, useRotation, optimize, #);
     norT = norOut[1];
@@ -1145 +1145 @@
       fT = f;
     }
-    
+
     ideal ibN = ibAt0(fT, locBasis, optimize);
 
@@ -1194 +1194 @@
   intvec vy = (0,1);
   int dbg = printlevel - voice;
-  
+
   // 1) Compute Puiseux sets (we use segments for easier implementation)
   list pSegmentFull = getSegments(f, classes, slopes, degExpand);
   list pSegment = pSegmentFull[1]; // The segments corresponding to expansions at the origin
   poly unitPoly = pSegmentFull[2]; // The unit outside the origin
-  dbprint(dbg, "Step 1 finished");  
-  
+  dbprint(dbg, "Step 1 finished");
+
   // 2) Compute IB in each set
   list ibSeg;
@@ -1210 +1210 @@
   }
   dbprint(dbg, "Step 2 finished");
-      
+
   // 3) Merge all the integral basis for the segments using the combinatorial approach
   list ib = optiBase(ibSeg, pSegment);
   dbprint(dbg, "Step 3 finished");
-    
+
   // 4) We add the unit outside the origin and convert to ib shape.
   ideal IOut;
   int intExp = int(ib[size(ib)-1][1]);
   poly condu = var(1)^intExp;  // The denominator of the integral basis.
-  
+
   for(k = 0; k < deg(unitPoly, vy); k++)
   {
@@ -1231 +1231 @@
   return(IOut);
 }
-  
+
 
 ///////////////////////////////////////////////////////////////////////
@@ -1256 +1256 @@
 
   number slopeSegment;
-    
+
   list out;
 
@@ -1277 +1277 @@
     list fGlob = henselGlobal(y^fl[2], fl[1], f, maxOrder);
     poly fLoc = fGlob[1];
-    
+
     if(fLoc == 1)
     {
@@ -1287 +1287 @@
     fSegment = henselSegments(fLoc, maxOrder);
     dbprint(dbg, "Number of segments: ", size(fSegment));
-    
+
     list pExpRecomputed;
     list nPoly;
-    
+
     //"Check output of henselSegments";
     //fSegment;
@@ -1307 +1307 @@
         {
           // If slopes coincide we add the class to the list
-          classesNew[size(classesNew) + 1] = classes[j];  
+          classesNew[size(classesNew) + 1] = classes[j];
         }
-      }  
-      
-      // If the number of classes in the segments is larger than one, 
+      }
+
+      // If the number of classes in the segments is larger than one,
       // we need to recompute expansions up to degree maxOrder so that
       // the factors can be computed correctly.
-      if(size(classesNew) > 1) 
+      if(size(classesNew) > 1)
       {
         // puiseux(poly f, int maxDeg, int atOrigin)
@@ -1321 +1321 @@
         classesNew = getClasses(pExpRecomputed);
       }
-      
+
       // We put everything together
       out[i] = list(fSegment[i], slopeSegment, classesNew);
     }
   }
-  
+
   // We reorder according to the slope
   out = sortSegments(out);
-  
+
   // We also return the unit outside the origin
   list outFull = list(out, fGlob[2]);
@@ -1367 +1367 @@
   intvec degPolySet;
   intvec vy = (0,1);
-  
+
   // We get all the possible polynomials, including the full polys
   //"Building factors from classes...";
   list bF = buildFactors(classes);
-  
+
   int degF = deg(f, vy);
-  
+
   // We consider the union of all polynomials
   poly pGround;
@@ -1386 +1386 @@
       }
     }
-    
+
     // We compute the full polynomial up to the integrality exponent.
     // When there is only one class we use the polynomial obtained from Hensel lifting.
@@ -1403 +1403 @@
     }
   }
-  
+
   // Degrees of the polynomials
   for(i = 1; i <= size(polySet); i++)
@@ -1409 +1409 @@
     degPolySet[i] = deg(polySet[i], vy);
   }
-  
+
   // We compute the order of each expansion at each of the polynomials
   list ordExpAtPoly;
@@ -1425 +1425 @@
   return(ib);
 }
-  
-// For each degree up to the degree of f, we compute the best 
+
+// For each degree up to the degree of f, we compute the best
 // possible product of factors by checking exhaustively all possible
 // combinations such that the product has the correct degree.
@@ -1441 +1441 @@
   intvec cBest;
   poly pBest;
-  
+
   // The first element is polynomial 1
   intvec zero = 0 * (1..s);
   ib[1] = list(0, zero, 1);
-  
+
   for (d = 1; d <= degF; d++)
   {
     // The best element of degree d;
     oMax  = 0;
-    
+
     // We generate the list of all possible combinations
     c = summandsFac(degPolySet, d);
-    
+
     // We compute the valuation of each combination,
     // and we keep the largest one.
@@ -1485 +1485 @@
   //"c, ordExpAtPoly";
   //c, ordExpAtPoly;
-  
+
   number o;
   number oBest;
@@ -1502 +1502 @@
           if(ordExpAtPoly[i][j] >= 0)
           {
-            o = o + c[i] * ordExpAtPoly[i][j];   // We consider c[i] equal factors, each one with valuation 
+            o = o + c[i] * ordExpAtPoly[i][j];   // We consider c[i] equal factors, each one with valuation
                                                  // ordExpAtPoly[i][j] at the jth Puiseux expansion
           } else {
@@ -1550 +1550 @@
 }
 
-  
+
 //We implement the optimization approach from scratch
 proc optiBase(list ibSeg, list segmentSlope)
@@ -1556 +1556 @@
   int i, k;
   int s = size(ibSeg);
-  
+
   if(s == 1) {return(ibSeg[1]);}
-  
+
   // We initialize the recursion step
   list ibSegRec = ibSeg[s];
   list segmentSlopeRec = segmentSlope[s]; // Should be fixed to contain only slopes
-  
+
   for(k = s-1; k >= 1; k--)
   {
@@ -1575 +1575 @@
 {
   //"optiTwoSets begin...";
-  
+
   int s1 = size(ib1)-1;  // max degree
   int s2 = size(ib2)-1;  // max degree
@@ -1581 +1581 @@
   intvec cBest;
   int d;
-  
+
   //"s1 + s2 = ", s1 + s2;
-  
+
   number o, o1, o2;
   number oBest;
   poly polyBest;
-  
+
   list out;
   out[1] = list(0, intvec(0,0), 1);
   // Best element of degree d
-  
+
   int m1, m2;
   for(d = 1; d <= s1 + s2; d++)
@@ -1615 +1615 @@
         {
           o = o2;
-        } else 
+        } else
         {
-          if(c2 == s2) 
+          if(c2 == s2)
           {
             o = o1;
-          } else 
+          } else
           {
             if(o1 < o2) {o = o1;}
@@ -1627 +1627 @@
         }
         //"c1 = ", c1, "c2 = ", c2, "s1 = ", s1, "s2 = ", s2, "o = ", o;
-        
+
         if(o > oBest)
         {
@@ -1639 +1639 @@
   }
   //"optiTwoSets finished...";
-  
+
   return(out);
 }
-    
-  
+
+
 
 ////////////////////////////////////////////////////////////////////////
@@ -1687 +1687 @@
   // puiseux(poly f, int maxDeg, int atOrigin)
   list pExp = puiseux(f, -1, 1);
-  
+
   debug_log_intbas(3, "------Time puiseux expansions: ", timer - tt);
   tt = timer;
@@ -1708 +1708 @@
   dbprint(dbg, "--Computing vanishing orders...");
   matrix MClass = valIKClass(classes);
-  
+
   list vS = valIKSelf(bF, md);
   list MSelf = vS[1];
   list bestElem = vS[2];
-  
+
 
   // The highest exponent of the denominator
@@ -1733 +1733 @@
     }
   }
-  
+
   dbprint(dbg, "The maximum integrality exponent is ", maxExp);
-  
+
   debug_log_intbas(3, "------Time for factors info: ", timer - tt);
   tt = timer;
@@ -1741 +1741 @@
   int degExpand = int(maxExp) + 1;
   dbprint(dbg, "---- Degree of expansions: ", degExpand);
-  
+
   if((pardeg(minpoly) > 0) and (optimize == 1))
   {
@@ -1763 +1763 @@
   int i, j, k;
   intvec vy = (0,1);
-   
+
   // Computing hensel blocks...
   dbprint(dbg, "--Building HenselBlocks...");
@@ -1830 +1830 @@
     blocks[1] = 1;
     matrix M = valIK(classes);
-  
+
   }
 
@@ -1860 +1860 @@
 
   debug_log_intbas(3, "------Time for ordFull: ", timer - tt);
-  
+
   tt = timer;
 
@@ -1885 +1885 @@
   int mdm = 0;
   int mdmTemp;
-  
+
   // maxDegMerge computes the maximum degree required when adding the
   // factors from the Chinese remainder approach
@@ -1906 +1906 @@
   // The classes are reordered in the same order as the irreducible factors
   classes = ifOut[5];
-  
+
   if((ifOut[4] == 1))  // Wrong number of factors, recompute orders
   {
@@ -2015 +2015 @@
     //debug_log_intbas(3, "------Time for recomputation: ", timer - tt);
   }
-  
+
   ideal tmp_var_mdm=std(var(1)^mdm);
   for(i = 1; i <= size(I2LiftedFull); i++)
@@ -2142 +2142 @@
   //ideal IOut = ibOrigin(fT, locBasis);
   ideal IOut = ibAt0(fT, locBasis, optimize);
-  
+
   list ib = intBasIdealToList(IOut);
 
@@ -2462 +2462 @@
   int dbg = printlevel - voice + 4;
   dbprint(dbg, "--buildFactors begins");
-  
+
   int i, j;
   int d = -1;
@@ -2490 +2490 @@
 
   list polyGround;
-  
+
   int isGround = 1;
-    
+
   int algExt;
   for(i = 1; i <= size(classes); i++)
@@ -2504 +2504 @@
     first = 1;
     stop1 = 0;
-    
+
     // If the denominator is 1 there is nothing to do
-    
+
     algExt = 0;
     if(typeof(classes[i][1]) == "ring")
@@ -2516 +2516 @@
       if(classes[i][1][2] > 1) {algExt = 1;}
     }
-    
+
     if(algExt == 1)
     {
@@ -2545 +2545 @@
         den = classes[i][1][2];
       }
-      exps = expsT;      
+      exps = expsT;
       //"exponents for class ", i, " = ", expsT;
-      
+
       for(k = 1; k <= size(exps); k++)
       {
@@ -2567 +2567 @@
           S = classes[i][1];
           setring S;
-          
+
           // d = -1 for computing polynomial of full degree
           if(d >= 0){
@@ -2583 +2583 @@
             ideal rel = extendBack(fFB, erg[1], dMP);
             matrix CC = coef(fFB, var(1)*var(2));
-            
+
             setring R;
             ideal rel = imap(S, rel);
@@ -2633 +2633 @@
           ind++;
           isGround = 0;
-        } else 
+        } else
         {
           debug_log_intbas(4, "------Time for this factor: ", timer - t);
@@ -2663 +2663 @@
         {
           ords[i][ind] = number(d) / number(den);
-        } else 
+        } else
         {
           ords[i][ind] = number(deg(facs[i][ind],vx)) / number(den);
@@ -2679 +2679 @@
     }
   }
-  
+
   return(list(facs, ords, degs, gfChecks, isGround));
 }
@@ -2700 +2700 @@
 
   poly mp = minpoly;
-  
+
   mp = subst(minpoly, @a, var(1));
   int d = pardeg(minpoly);
@@ -2768 +2768 @@
 
   poly mp = minpoly;
-  
+
   mp = subst(minpoly, @a, var(1));
   int d = pardeg(minpoly);
@@ -2918 +2918 @@
   intvec dx = (1,0);
   int degX = deg(f, dx);
-  
+
   if(d == -1) {d = degX + 1;}
-  
+
   //"Check buildPG";
   //f;
@@ -2931 +2931 @@
     def S = ring(l);
     setring S;
-    
+
     // We divide the exponents by the GCD of the exponents and the degree of the extension
     poly ff;
@@ -2940 +2940 @@
     list ffList = buildPolyGround(list(ff), g2);
     poly ffRed = ffList[1];
-    
+
     list pols;
     pols[1] = ffRed;
@@ -2948 +2948 @@
       pols[i+1] = ff;
     }
-    
+
     if(den > 1)
     {
-      // T(1) is a den-th root of unity, the only relation is 
+      // T(1) is a den-th root of unity, the only relation is
       // 0 = 1 + T(1) + ... + T(1)^(den-1)
       poly pExt = 1; // A root of unity
@@ -2960 +2960 @@
       ideal I = pExt;
       I = groebner(I);
-          
+
       poly fNewTemp = 1;
       for(i = 1; i<=den; i++)
@@ -2977 +2977 @@
       poly fNew = reduce((var(2) - ffRed), groebner(var(1)^(d*den+1)));
     }
-    
+
     // We replace x^den by x
     ring P = (0, @a), (@x, @y, @X), dp;
@@ -2988 +2988 @@
     }
     f2 = subst(f2, @X, @x);
-        
+
     setring R;
     poly fNew = fetch(P, f2);
@@ -2996 +2996 @@
       // We look for a polynomial over Q.
       // This algorithm is not implemented for complex singularities.
-      // In that case we would need to distinguish the extension in the basering 
+      // In that case we would need to distinguish the extension in the basering
       // from the extension in the Puiseux expansion, as in buildPolyFracNew.
       fNew = multiplicateConjugates(fNew);
@@ -3013 +3013 @@
   matrix M = coef(f,var(indVar));
   int g;
-  for(int i = 1; i <= ncols(M); i++) 
+  for(int i = 1; i <= ncols(M); i++)
   {
     if(i == 1){g = leadexp(M[1,1])[indVar];}
@@ -3033 +3033 @@
 //         The common denominator is now cancelled with the numerators.
 static proc buildPolyGround(list fFrac, int sD)
-{  
+{
   int i;
   int gfCheck = 1;  // The polynomial computed is over the ground field.
@@ -3201 +3201 @@
 //         proc getClasses
 // Output: a matrix M of number, where M[i, j] is the valuation
-//         of gamma_i at the product of the conjugated factors (Y - gamma_j), 
+//         of gamma_i at the product of the conjugated factors (Y - gamma_j),
 //         expansions of the i-th and j-th conjugacy class respectively.
 static proc valIKClass(list classes)
@@ -3208 +3208 @@
   def R = basering;
   matrix MC[size(classes)][size(classes)];
-  
+
   // Order for each class of expansions
   for(i = 1; i <= size(classes); i++)
@@ -3243 +3243 @@
   poly differ;
   number ordDiff;
-  
-  list l; 
-  
+
+  list l;
+
   for(i = 1; i <= size(classes); i++)
   {
@@ -3369 +3369 @@
     for(j = 1; j <= s; j++)
     {
-      if(i == j) 
+      if(i == j)
       {
         //"md = ", md;
         //"i = ", i;
-        if(md[i] > 1) 
+        if(md[i] > 1)
         {
           minOrd = minOrd + number(MSelf[i][md[i]-1]);
         }
         //"it worked";
-      } else 
+      } else
       {
         minOrd = minOrd + number(M[i,j]);
@@ -3466 +3466 @@
     }
   }
-  
+
   intvec elem = sums[maxExpi];
   return(list(maxExp, elem));
@@ -3773 +3773 @@
       setring S;
       // The number of conjugated expansions is the common demoninator of the exponents times the degree of the extension,
-      // except when the algebraic extension comes from taking root of unity. 
+      // except when the algebraic extension comes from taking root of unity.
       // This degree should be checked if it is always correct computation, or if we should compute this number
       // while computing the Puiseux expansions.
@@ -3932 +3932 @@
   int dbg = printlevel - voice - 2;
   dbprint(dbg, "START - irreducibleFactors");
-  
+
   list I2Lifted = henselBlocks(f, degExpand, 1);
-  
+
   list updatedClasses = classes;
   int nClasses;
@@ -3995 +3995 @@
 
         newL = puiseux(I2Red, degExpand, 1);
-        
+
         classes2 = getClasses(newL);
         dbprint(dbg, "getClasses finished");
@@ -4014 +4014 @@
             def S = classes2[j][1];
             setring S;
-            
+
             list bP = buildPolyGroundXRoot(PE[1][1], PE[1][2], degExpand);
-            
+
             //"bP ring", bP;
 
@@ -4033 +4033 @@
             fuProd = bP[1];
             gfCheck = bP[2];
-            
+
             //"bP poly", bP;
-            
+
           }
 
@@ -4122 +4122 @@
     // The first term containing the locloc unit
     expBaseFactor = expUnit;
-       
+
     // If the order of hi is not integer, we add a factor.
     // This is used in the Chinese remainder strategy
@@ -5053 +5053 @@
     dbprint(dbg, "----Computing Puiseux Segments...");
     fSegment = henselSegments(fLoc, maxOrder);
-    
+
     //"Check output of henselSegments";
     //fSegment;
-    
+
     for(i = 1; i <= size(fSegment); i++)
     {
@@ -5176 +5176 @@
   poly ratPart;
   list compsT;
-  
+
   dbprint(dbg, "sFac = ", sFac);
   for(i = 1; i <= sFac; i++)
@@ -5183 +5183 @@
     hFactor[i] = hFactor[i] * (var(1)^(degFac * slN));
     hFactor[i] = mapFrom(hFactor[i], slN, slD);
-  
+
     dbprint(dbg, "henselInSegment - splitFact - i = ", i);
     compsT = splitFact(hFactor[i], fJe[1][i+1], fJe[2][i+1], globOrder);
     dbprint(dbg, "henselInSegment - splitFact - finished");
-    
+
     for(j = 1; j <= size(compsT); j++)
     {

Singular/LIB/normal.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
-version="version normal.lib 4.3.1.1 Jan_2023 "; // $Id$
+version="version normal.lib 4.3.2.10 Nov_2023 "; // $Id$
 category="Commutative Algebra";
 info="
@@ -77 +77 @@
          If this option is not set, normal changes to dp ordering and performs
          all computations with respect to this ordering.@*
-         - \"withDelta\" (or \"wd\") -> returns also the delta invariants. 
+         - \"withDelta\" (or \"wd\") -> returns also the delta invariants.
          Not valid for options \"locNormal\" and \"modNormal\".@*
          If the optional parameter choose is not given or empty, only
@@ -97 +97 @@
          - \"var2\" -> uses a polynomial in the second variable as universal
          denominator.@*
-         - \"GBRadical\" -> it computes a Groebner basis of the radical 
+         - \"GBRadical\" -> it computes a Groebner basis of the radical
          ideal computed for the test ideal.@*
-         - \"noGBRadical\" -> it does not compute a Groebner basis of 
+         - \"noGBRadical\" -> it does not compute a Groebner basis of
          the radical ideal computed for the test ideal.@*
-         - \"locNormal\" -> uses locNormal procedure to compute the 
+         - \"locNormal\" -> uses locNormal procedure to compute the
          normalization, which implements a local-to-global algorithm
          (for this option it is required that the ideal I is prime).@*
@@ -107 +107 @@
          use modNormal algorithm for the local computations.@*
          - \"modNormal\" -> uses modNormal procedure to compute the
-         normalization, which implements a modular algorithm (for this 
+         normalization, which implements a modular algorithm (for this
          option it is required that the ideal I is prime).@*
          - list(\"nPrimes\", int n) -> parameter for modNormal. We consider
-         n primes at a time until the result lifted to the rationals is 
+         n primes at a time until the result lifted to the rationals is
          correct modulo one additional prime. (default: n = 10)@*
-         - \"noVerification\" -> if the modular approach is used (using 
-         modNormal option or modular option in locNormal), the 
+         - \"noVerification\" -> if the modular approach is used (using
+         modNormal option or modular option in locNormal), the
          result will not be verified.@*
          If the optional parameter choose is not given or empty, only
@@ -119 +119 @@
          - \"withRing\" -> the ring structure of the normalization is
          computed. The number of variables in the new ring is reduced as much
-         as possible. This is the default option, except when using 
+         as possible. This is the default option, except when using
          modNormal or locNormal options.@*
 ASSUME:  The ideal must be radical, for non-radical ideals the output may
@@ -126 +126 @@
          and hence normal computes the normalization of the radical of id.@*
 NOTE:    \"isPrim\" should only be used if id is known to be prime.
-RETURN:  If \"withRing\" option is set, a list, say nor, of size 2 
+RETURN:  If \"withRing\" option is set, a list, say nor, of size 2
          (resp. 3 with option \"withDelta\").
          Let R denote the basering and id the input ideal.
@@ -149 +149 @@
          the total delta invariant of basering/id (-1 means infinite, and 0
          that R/P_i resp. R/id is normal).@*
-         If \"withRing\" option is not set, a list of an ideal U and 
+         If \"withRing\" option is not set, a list of an ideal U and
          a polynomial d such that U/d is the normalization
 THEORY:  We use here a general algorithm described in [G.-M.Greuel, S.Laplagne,
@@ -198 +198 @@
       opt = remove_from_list(opt, "locNormal");
       list out = locNormal(id, opt);
-    }  
+    }
     if(in_array(#, "withRing")) {
       // We compute the ring structure
-      def outRing = computeRing(out[1], id);  
-      
+      def outRing = computeRing(out[1], id);
+
       // We put the conductor as the last element of the ideal.
       ideal OO = reduce(out[1], groebner(out[2]));
       OO = interred(OO);
       OO[ncols(OO)+1]=out[2];
-      
+
       list outWR = list(list(outRing), list(OO));
       return(outWR);
@@ -214 +214 @@
     }
   }
-  
-  
+
+
   ASSUME(0, not isQuotientRing(basering) );
 
@@ -4846 +4846 @@
   printlevel = printlevel + 1;
 
-  if(normalCheck == 1) 
+  if(normalCheck == 1)
   {
     int out = normalMEqui(I, J, condu, D, withDelta, normalCheck, options);
@@ -5256 +5256 @@
 
 // Checks if string s is an element of list l
-proc in_array(list l, string s)
+static proc in_array(list l, string s)
 {
   int i;
@@ -5298 +5298 @@
   return(0);
 }
-  
+
 
 static proc testIdeal(ideal I, ideal U, ideal origJ, poly c, poly D, list options)
@@ -5304 +5304 @@
 
   ASSUME(1, not isQuotientRing(basering) );
-  
-  
+
+
 
 // Internal procedure, used in normalM.
@@ -5372 +5372 @@
     //"DEBUG - we do not compute the GB of radical output";
   }
- 
+
   if(dbg > 1)
   {
@@ -5450 +5450 @@
   ideal J = imap(R, J);
   poly c = imap(R, c);
-  
+
   t = timer;
   for(i = 1; i<=ncols(J); i++)
@@ -5475 +5475 @@
   // --------------------------- prepare output ----------------------------
   // Groebner basis in the ring with only the original variables
-  
+
   t = timer;
   J = groebner(J);
@@ -7180 +7180 @@
 //           S. Steidel      steidel@mathematik.uni-kl.de
 // @*
-// 
+//
 // OVERVIEW:
 // Suppose A is an affine domain over a perfect field.@*
@@ -7188 +7188 @@
 // reconstruction as described in [3]. This approach is inherently parallel.@*
 // The strategy is available both as a randomized and as a verified algorithm.
-// 
+//
 // REFERENCES:
-// 
+//
 // [1] Janko Boehm, Wolfram Decker, Santiago Laplagne, Gerhard Pfister, Stefan Steidel,
 // Andreas Steenpass: Parallel algorithms for normalization, preprint, 2011.
-// 
+//
 // [2] Gert-Martin Greuel, Santiago Laplagne, Frank Seelisch: Normalization of Rings,
 // Journal of Symbolic Computation 9 (2010), p. 887-901
-// 
+//
 // [3] Janko Boehm, Wolfram Decker, Claus Fieker, Gerhard Pfister:
 // The use of Bad Primes in Rational Reconstruction, preprint, 2012.
-// 
+//
 // KEYWORDS:
 // normalization; modular methods
@@ -7684 +7684 @@
 //           S. Steidel      steidel@mathematik.uni-kl.de
 //           A. Steenpass    steenpass@mathematik.uni-kl.de
-// 
+//
 // OVERVIEW:
-// 
+//
 // Suppose A is an affine domain over a perfect field.@*
 // This library implements a local-to-global strategy for finding the normalization
@@ -7694 +7694 @@
 // Furthermore we allow for the optional modular computation of the local results
 // as provided by modnormal.lib. See again [1] for details.
-// 
+//
 // REFERENCES:
-// 
+//
 // [1] Janko Boehm, Wolfram Decker, Santiago Laplagne, Gerhard Pfister, Stefan Steidel,
 // Andreas Steenpass: Parallel algorithms for normalization, http://arxiv.org/abs/1110.4299, 2011.
-// 
+//
 // [2] Gert-Martin Greuel, Santiago Laplagne, Frank Seelisch: Normalization of Rings,
 // Journal of Symbolic Computation 9 (2010), p. 887-901
-// 
+//
 // KEYWORDS:
 // normalization; modular methods