Changeset 3c4dcc in git for Singular/LIB/hnoether.lib

Timestamp:

May 6, 2005, 4:39:20 PM (19 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

0d217d3f1cc4c0449bdb078c65fd1f43cd1a2b84

Parents:

e6fb5315eb32da00236163ce10f9bdafaaa0bd47

Message:

*hannes: DOS->UNIX and white space cleanup


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

File:

• Singular/LIB/hnoether.lib (modified) (106 diffs)

Singular/LIB/hnoether.lib

@@ -1 @@
--       version="$Id: hnoether.lib,v 1.47 2005-04-26 17:19:14 Singular Exp $";
+version="$Id: hnoether.lib,v 1.48 2005-05-06 14:38:35 hannes Exp $";
 category="Singularities";
 info="
@@ -7 +7 @@
 
 OVERVIEW:
- A library for computing the Hamburger-Noether expansion (analogue of 
- Puiseux expansion over fields of arbitrary characteristic) of a reduced 
+ A library for computing the Hamburger-Noether expansion (analogue of
+ Puiseux expansion over fields of arbitrary characteristic) of a reduced
  plane curve singularity following [Campillo, A.: Algebroid curves in
  positive characteristic, Springer LNM 813 (1980)]. @*
@@ -219 +219 @@
   f_neu=Tstar(f_neu);
   refpoly=Tstar(refpoly);
-  //--- dividiere f_neu so lange durch x & y, wie die Division aufgeht, 
-  //    benutze ein Referenzpolynom mit gleichem Newtonpolynom wie f_neu zur 
+  //--- dividiere f_neu so lange durch x & y, wie die Division aufgeht,
+  //    benutze ein Referenzpolynom mit gleichem Newtonpolynom wie f_neu zur
   //    Beschleunigung: ---
   for (hilf=refpoly/xp; hilf*xp==refpoly; hilf=refpoly/xp) {refpoly=hilf; s++;}
@@ -529 +529 @@
            );
  }
- 
+
  string namex=varstr(1); string namey=varstr(2);
  list return_error=matrix(maxideal(1)[2]),intvec(0),int(-1),poly(0),int(0);
@@ -807 +807 @@
       f = T1_Transform(f,delt,M/ e);
       dbprint(printlevel-voice+2,"a("+string(zeile)+","+string(Q)+") = "
-              +string(delt)); 
+              +string(delt));
       a(zeile)[Q]=delt;
       if (defined(HNDebugOn)) {"transformed polynomial: ",f;}}
@@ -815 +815 @@
  //--------------------------- Fall R > 0 : -----------------------------------
   else {
-    dbprint(printlevel-voice+2, "h("+string(zeile)+ ") ="+string(Q)); 
+    dbprint(printlevel-voice+2, "h("+string(zeile)+ ") ="+string(Q));
     hqs[zeile+1]=Q;                  // denn zeile beginnt mit dem Wert 0
     a(zeile)[Q+1]=x;                 // Markierung des Zeilenendes der HNE
@@ -830 +830 @@
  //--------------- schneidet das Newtonpolygon beide Achsen? ------------------
   if (M==-1) {
-     dbprint(printlevel-voice+2,"The HNE is finite!"); 
+     dbprint(printlevel-voice+2,"The HNE is finite!");
      a(zeile)[Q+1]=x;   // Markiere das Ende der Zeile
      hqs[zeile+1]=Q;
@@ -915 +915 @@
 "USAGE:  param(L [,s]); L list, s any type (optional)
 ASSUME:  L is the output of @code{develop(f)}, or of
-        @code{extdevelop(develop(f),n)}, or (one entry in) the list of HN 
+        @code{extdevelop(develop(f),n)}, or (one entry in) the list of HN
         data created by @code{hnexpansion(f[,\"ess\"])}.
-RETURN: If L are the HN data of an irreducible plane curve singularity f: a 
+RETURN: If L are the HN data of an irreducible plane curve singularity f: a
         parametrization for f in the following format: @*
         - if only the list L is given, the result is an ideal of two
         polynomials p[1],p[2]: if the HNE was finite then f(p[1],p[2])=0};
-        if not, the true parametrization will be given by two power series, 
+        if not, the true parametrization will be given by two power series,
         and p[1],p[2] are truncations of these series.@*
         - if the optional parameter x is given, the result is a list l:
@@ -928 +928 @@
         l[1] are exact (entry -1 means that the corresponding parametrization
         is exact).
-        If L collects the HN data of a reducible plane curve singularity f, 
-        the return value is a list of parametrizations in the respective 
-        format. 
+        If L collects the HN data of a reducible plane curve singularity f,
+        the return value is a list of parametrizations in the respective
+        format.
 NOTE:   If the basering has only 2 variables, the first variable is chosen
         as indefinite. Otherwise, the 3rd variable is chosen.
@@ -947 +947 @@
    for (int i=1; i<=size(L); i++) {
      dbprint(printlevel-voice+4,"// Parametrization of branch number "
-       +string(i)+" computed.");  
+       +string(i)+" computed.");
      printlevel=printlevel+1;
      if (return_list==1) { Ergebnis[i]=param(L[i],1); }
@@ -1026 +1026 @@
          "// ** Warning: result is exact up to order "+string(fehlervor-1)+
          " in "+ string(var(1))+" and "+string(fehler-1)+" in " +
-         string(var(2))+" !"); 
+         string(var(2))+" !");
      }
      else {
@@ -1043 +1043 @@
          "// ** Warning: result is exact up to order "+string(fehler-1)+
          " in "+ string(var(1))+" and "+string(fehlervor-1)+" in " +
-         string(var(2))+" !"); 
+         string(var(2))+" !");
      }
      else {
@@ -1080 +1080 @@
 "USAGE:   invariants(INPUT); INPUT list or poly
 ASSUME:  @code{INPUT} is the output of @code{develop(f)}, or of
-         @code{extdevelop(develop(f),n)}, or one entry of the list of HN data 
+         @code{extdevelop(develop(f),n)}, or one entry of the list of HN data
          computed by @code{hnexpansion(f[,\"ess\"])}.
 RETURN:  list @code{INV} of the following format:
@@ -1091 +1091 @@
     INV[6]:  intvec    (sequence of multiplicities)
 @end format
-         If @code{INPUT} contains no valid HN expansion, the empty list is 
+         If @code{INPUT} contains no valid HN expansion, the empty list is
          returned.
-ASSUME:  @code{INPUT} is a bivariate polynomial f, or the output of 
-         @code{hnexpansion(f)}, or the list of HN data computed by 
+ASSUME:  @code{INPUT} is a bivariate polynomial f, or the output of
+         @code{hnexpansion(f)}, or the list of HN data computed by
          @code{hnexpansion(f [,\"ess\"])}.
-RETURN:  list @code{INV}, such that @code{INV[i]} coincides with the output of 
-         @code{invariants(develop(f[i]))}, where f[i] is the i-th branch of 
-         f, and the last entry of @code{INV} contains further invariants of 
+RETURN:  list @code{INV}, such that @code{INV[i]} coincides with the output of
+         @code{invariants(develop(f[i]))}, where f[i] is the i-th branch of
+         f, and the last entry of @code{INV} contains further invariants of
          f in the format:
 @format
@@ -1129 +1129 @@
       else {
         return(invariants(L));
-      }  
+      }
    }
    if (typeof(#[1])=="ring") {
@@ -1137 +1137 @@
      setring altring;
      kill HNring;
-     return(Ergebnis);  
+     return(Ergebnis);
    }
    if (typeof(#[1])=="list") {
@@ -1241 +1241 @@
  {
    tester=tester-1;
- } 
+ }
  if ((multseq[tester]!=1) and (multseq[tester]!=k-tester))
  {
@@ -1247 +1247 @@
    {
      multseq[i]=1;
-   }   
+   }
  }
  //--- Ende T.Keilen --- 06.05.02
@@ -1279 +1279 @@
 proc displayInvariants
 "USAGE:  displayInvariants(INPUT); INPUT list or poly
-ASSUME:  @code{INPUT} is a bivariate polynomial, or the output of 
-         @code{develop(f)}, resp. of @code{extdevelop(develop(f),n)}, or (one 
-         entry of) the list of HN data computed by 
+ASSUME:  @code{INPUT} is a bivariate polynomial, or the output of
+         @code{develop(f)}, resp. of @code{extdevelop(develop(f),n)}, or (one
+         entry of) the list of HN data computed by
          @code{hnexpansion(f[,\"ess\"])}.
 RETURN:  none
@@ -1356 +1356 @@
     "";
   }
-  if (size(#)>1) 
+  if (size(#)>1)
   {
     " -------------- contact numbers : -------------- ";"";
     Ausgabe="branch |   ";
-    for (j=size(#); j>1; j--) 
+    for (j=size(#); j>1; j--)
     {
       if (size(string(j))==1) { Ausgabe=Ausgabe+" "+string(j)+"    "; }
       else                    { Ausgabe=Ausgabe+string(j)+"    "; }
-    }   
+    }
     Ausgabe;
     Ausgabe="-------+";
@@ -1370 +1370 @@
     Ausgabe=Ausgabe+"-----";
     Ausgabe;
-  } 
-  for (j=1; j<size(#); j++) 
+  }
+  for (j=1; j<size(#); j++)
   {
     if (size(string(j))==1) { Ausgabe="    "+string(j)+"  |"; }
     else                    { Ausgabe="   " +string(j)+"  |"; }
-    for (k=size(#); k>j; k--) 
+    for (k=size(#); k>j; k--)
     {
       mul=contact[j,k];//separateHNE(#[j],#[k]);
@@ -1385 +1385 @@
   }
   "";
-  if (size(#)>1) 
+  if (size(#)>1)
   {
     " -------------- intersection multiplicities : -------------- ";"";
     Ausgabe="branch |   ";
-    for (j=size(#); j>1; j--) 
+    for (j=size(#); j>1; j--)
     {
       if (size(string(j))==1) { Ausgabe=Ausgabe+" "+string(j)+"    "; }
       else                    { Ausgabe=Ausgabe+string(j)+"    "; }
-    }   
+    }
     Ausgabe;
     Ausgabe="-------+";
@@ -1399 +1399 @@
     Ausgabe=Ausgabe+"-----";
     Ausgabe;
-  } 
-  for (j=1; j<size(#); j++) 
+  }
+  for (j=1; j<size(#); j++)
   {
     if (size(string(j))==1) { Ausgabe="    "+string(j)+"  |"; }
     else                    { Ausgabe="   " +string(j)+"  |"; }
-    for (k=size(#); k>j; k--) 
+    for (k=size(#); k>j; k--)
     {
       mul=intersectionmatrix[j,k];//intersection(#[j],#[k]);
@@ -1415 +1415 @@
   "";
   " -------------- delta invariant of the curve : ",ergebnis[size(#)+1][3];
-  
+
  }
  return();
@@ -1504 +1504 @@
 proc intersection (list hn1, list hn2)
 "USAGE:   intersection(hne1,hne2); hne1, hne2 lists
-ASSUME: @code{hne1, hne2} represent an HN expansion of an irreducible plane 
+ASSUME: @code{hne1, hne2} represent an HN expansion of an irreducible plane
         curve singularity (that is, are the output of @code{develop(f)}, or of
         @code{extdevelop(develop(f),n)}, or one entry of the list of HN data
         computed by @code{hnexpansion(f[,\"ess\"])}).
-RETURN:  int, the intersection multiplicity of the irreducible plane curve 
+RETURN:  int, the intersection multiplicity of the irreducible plane curve
          singularities corresponding to @code{hne1} and @code{hne2}.
 SEE ALSO: hnexpansion, displayInvariants
@@ -1611 +1611 @@
 
 proc multsequence
-"USAGE:   multsequence(INPUT); INPUT list or poly 
+"USAGE:   multsequence(INPUT); INPUT list or poly
 ASSUME:  @code{INPUT} is the output of @code{develop(f)}, or of
-         @code{extdevelop(develop(f),n)}, or one entry of the list of HN data 
+         @code{extdevelop(develop(f),n)}, or one entry of the list of HN data
          computed by @code{hnexpansion(f[,\"ess\"])}.
 RETURN:  intvec corresponding to the multiplicity sequence of the irreducible
@@ -1619 +1619 @@
          coincides with @code{invariants(INPUT)[6]}).
 
-ASSUME:  @code{INPUT} is a bivariate polynomial f, or the output of 
-         @code{hnexpansion(f)}, or the list of HN data computed by 
+ASSUME:  @code{INPUT} is a bivariate polynomial f, or the output of
+         @code{hnexpansion(f)}, or the list of HN data computed by
          @code{hnexpansion(f [,\"ess\"])}.
 RETURN:  list of two integer matrices:
@@ -1636 +1636 @@
 @end table
 @end texinfo
-NOTE:  The order of the elements of the list of HN data obtained from 
+NOTE:  The order of the elements of the list of HN data obtained from
        @code{hnexpansion(f [,\"ess\"])} must not be changed (because otherwise
-       the coincident infinitely near points couldn't be grouped together, 
+       the coincident infinitely near points couldn't be grouped together,
        see the meaning of the 2nd intmat in the example).
        Hence, it is not wise to compute the HN expansion of polynomial factors
-       separately, put them into a list INPUT and call 
+       separately, put them into a list INPUT and call
        @code{multsequence(INPUT)}. @*
        Use @code{displayMultsequence} to produce a better readable output for
@@ -1667 +1667 @@
    else {
      return(multsequence(L));
-   }  
+   }
  }
  if (typeof(#[1])=="ring") {
@@ -1675 +1675 @@
    setring altring;
    kill HNring;
-   return(Ergebnis);  
+   return(Ergebnis);
  }
  //-- entferne ueberfluessige Daten zur Erhoehung der Rechengeschwindigkeit: --
@@ -1710 +1710 @@
     }
   }
-  //--- Ende T.Keilen --- 06.05.02  
+  //--- Ende T.Keilen --- 06.05.02
   return(multseq);
  }
@@ -1772 +1772 @@
 proc displayMultsequence
 "USAGE:   displayMultsequence(INPUT); INPUT list or poly
-ASSUME:  @code{INPUT} is a bivariate polynomial, or the output of 
-         @code{develop(f)}, resp. of @code{extdevelop(develop(f),n)}, or (one 
-         entry of) the list of HN data computed by @code{hnexpansion(f[,\"ess\"])}, 
+ASSUME:  @code{INPUT} is a bivariate polynomial, or the output of
+         @code{develop(f)}, resp. of @code{extdevelop(develop(f),n)}, or (one
+         entry of) the list of HN data computed by @code{hnexpansion(f[,\"ess\"])},
          or the output of @code{hnexpansion(f)}.
 RETURN:  nothing
@@ -1811 +1811 @@
      displayMultsequence(L);
      return();
-   }  
+   }
  }
  if (typeof(#[1])=="ring") {
    def HNring = #[1]; setring HNring;
    displayMultsequence(hne);
-   return();  
+   return();
  }
 
@@ -1852 +1852 @@
    }
  }
-} 
+}
 example
 {
@@ -1971 +1971 @@
 "USAGE:   displayHNE(L[,n]); L list, n int
 ASSUME:  L is the output of @code{develop(f)}, or of @code{exdevelop(f,n)},
-         or of @code{hnexpansion(f[,\"ess\"])}, or (one entry in) the list 
+         or of @code{hnexpansion(f[,\"ess\"])}, or (one entry in) the list
          @code{hne} in the ring created by @code{hnexpansion(f[,\"ess\"])}.
 RETURN:  - if only one argument is given and if the input are the HN data
@@ -1988 +1988 @@
         HN matrix.@*
         - if a second argument is given and if the input are the HN data
-        of an irreducible plane curve singularity, return a ring containing 
+        of an irreducible plane curve singularity, return a ring containing
         an ideal @code{HNE} as described above.@*
         - if L corresponds to the output of @code{hnexpansion(f)}
         or to the list of HN data computed by @code{hnexpansion(f[,\"ess\"])},
-        @code{displayHNE(L[,n])} shows the HNE's of all branches of f in the 
+        @code{displayHNE(L[,n])} shows the HNE's of all branches of f in the
         format described above. The optional parameter is then ignored.
 NOTE:  The 1st line of the above ideal (i.e., @code{HNE[1]}) means that
@@ -2061 +2061 @@
 
  // lossen: output modified (06/2004)
- if (size(#) == 0) 
+ if (size(#) == 0)
  {
    if (switch==0) {
@@ -2071 +2071 @@
 
    for (j=1; j<=ncols(HNE); j++){
-     string stHNE(j)=string(HNE[j]); 
+     string stHNE(j)=string(HNE[j]);
    }
    if (undef_bd<-1)
-   {   
+   {
      stHNE(size(v))=stHNE(size(v))+" + ..... (terms of degree >="
                                  +string(-undef_bd)+")";
    }
    if (undef_bd==-1)
-   {   
+   {
      stHNE(size(v))=stHNE(size(v))+" + ..... (terms of degree >="
                                  +string(colM+1)+")";
@@ -2086 +2086 @@
    if (switch==0) {
      stHNE(1) = "  "+string(var(size(v)+2))+" = "+stHNE(1);
-   } 
+   }
    else {
      stHNE(1) = "  "+string(var(size(v)+1))+" = "+stHNE(1);
-   }  
+   }
    stHNE(1);
    if (ncols(HNE)==1) {return();}
 
    if (switch==0) {
-     stHNE(2) = "  "+string(var(size(v)+1))+" = "+stHNE(2); 
-   } 
+     stHNE(2) = "  "+string(var(size(v)+1))+" = "+stHNE(2);
+   }
    else {
-     stHNE(2) = "  "+string(var(size(v)+2))+" = "+stHNE(2); 
-   }  
+     stHNE(2) = "  "+string(var(size(v)+2))+" = "+stHNE(2);
+   }
    stHNE(2);
 
    for (j=3; j<=ncols(HNE); j++){
-     stHNE(j)= "  "+"z(" +string(j-2)+ ") = "+stHNE(j); 
+     stHNE(j)= "  "+"z(" +string(j-2)+ ") = "+stHNE(j);
      stHNE(j);
    }
@@ -2161 +2161 @@
 RETURN:  list of intvecs (= coordinates x,y of the Newton polygon of f).
 NOTE:    Procedure uses @code{execute}; this can be avoided by calling
-         @code{newtonpoly(f,1)} if the ordering of the basering is @code{ls}. 
+         @code{newtonpoly(f,1)} if the ordering of the basering is @code{ls}.
 KEYWORDS: Newton polygon
 EXAMPLE: example newtonpoly;  shows an example
@@ -2194 +2194 @@
   else
   {
-    map xytausch=@RR,var(2),var(1); 
-  }
-  for (i=2; f!=0; i++) 
+    map xytausch=@RR,var(2),var(1);
+  }
+  for (i=2; f!=0; i++)
   {
      abbruch=0;
-     while (abbruch==0) 
+     while (abbruch==0)
      {
-        C=leadexp(f);          
+        C=leadexp(f);
         if(jet(f,A[2]*C[1]-A[1]*C[2]-1,intvec(A[2]-C[2],C[1]-A[1]))==0)
-        { 
-           abbruch=1; 
-        }       
-        else 
-        { 
-           f=jet(f,-C[1]-1,intvec(-1,0)); 
+        {
+           abbruch=1;
+        }
+        else
+        {
+           f=jet(f,-C[1]-1,intvec(-1,0));
         }
     }
     hilf=jet(f,A[2]*C[1]-A[1]*C[2],intvec(A[2]-C[2],C[1]-A[1]));
     H=leadexp(xytausch(hilf));
-    A=H[2],H[1]; 
+    A=H[2],H[1];
     L[i]=A;
     f=jet(f,A[2]*B[1]-1,intvec(A[2],B[1]-A[1]));
@@ -2241 +2241 @@
 ASSUME:  f is convenient, that is, f(x,0) != 0 != f(0,y);@*
          mu (optional) is Milnor number of f.@*
-         NP (optional) is output of @code{newtonpoly(f)}. 
+         NP (optional) is output of @code{newtonpoly(f)}.
 RETURN:  int: 1 if f in Newton non-degenerate, 0 otherwise.
 SEE ALSO: newtonpoly
@@ -2269 +2269 @@
           NP=newtonpoly(f);
           i=size(NP)+1;
-        }  
+        }
       }
     }
@@ -2290 +2290 @@
   }
 
-  if(mu==nN)                   
+  if(mu==nN)
   { // the Newton-polygon is non-degenerate
     return(1);
@@ -2309 +2309 @@
 
   // if already computed, one should give the Minor number and Newton polygon
-  // as second and third input: 
+  // as second and third input:
   int mu=milnor(g);
   list NP=newtonpoly(g);
@@ -2495 +2495 @@
     delt=-koeff(f,M,0)/koeff(f,M1,1);
     a[Q]=delt;
-    dbprint(printlevel-voice+2,"a("+string(zeile-1)+","+string(Q)+") = "+string(delt)); 
+    dbprint(printlevel-voice+2,"a("+string(zeile-1)+","+string(Q)+") = "+string(delt));
     if (Q<Exaktheit) {
      f=T1_Transform(f,delt,Q);
      if (defined(HNDebugOn)) { "transformed polynomial:",f; }
      if (subst(f,y,0)==0) {
-       dbprint(printlevel-voice+2,"The HNE is finite!"); 
+       dbprint(printlevel-voice+2,"The HNE is finite!");
        a[Q+1]=x; Exaktheit=Q;
        f=0;                        // Speicherersparnis: f nicht mehr gebraucht
@@ -2629 +2629 @@
 proc factorfirst(poly f, int M, int N)
 "USAGE : factorfirst(f,M,N); f poly, M,N int
-RETURN: number d such that f=const*(y^(N/e) - d*x^(M/e))^e, where e=gcd(M,N), 
+RETURN: number d such that f=const*(y^(N/e) - d*x^(M/e))^e, where e=gcd(M,N),
         0 if such a d does not exist
 EXAMPLE: example factorfirst;  shows an example
@@ -2681 +2681 @@
 ASSUME:  f is a bivariate polynomial (in the first 2 ring variables)
 RETURN:  list @code{L}, containing Hamburger-Noether data of @code{f}:
-         If the computation of the HNE required no field extension, @code{L} 
-         is a list of lists @code{L[i]} (corresponding to the output of 
+         If the computation of the HNE required no field extension, @code{L}
+         is a list of lists @code{L[i]} (corresponding to the output of
          @code{develop}, applied to a branch of @code{f}, but the last entry
          being omitted):
@@ -2689 +2689 @@
 @item @code{L[i][1]}; matrix:
          Each row contains the coefficients of the corresponding line of the
-         Hamburger-Noether expansion (HNE) for the i-th branch. The end of 
-         the line is marked in the matrix by the first ring variable 
+         Hamburger-Noether expansion (HNE) for the i-th branch. The end of
+         the line is marked in the matrix by the first ring variable
          (usually x).
 @item @code{L[i][2]}; intvec:
          indicating the length of lines of the HNE
 @item @code{L[i][3]}; int:
-         0  if the 1st ring variable was transversal (with respect to the 
+         0  if the 1st ring variable was transversal (with respect to the
             i-th branch), @*
          1  if the variables were changed at the beginning of the
@@ -2701 +2701 @@
         -1  if an error has occurred.
 @item @code{L[i][4]}; poly:
-         the transformed equation of the i-th branch to make it possible 
-         to extend the Hamburger-Noether data a posteriori without having 
+         the transformed equation of the i-th branch to make it possible
+         to extend the Hamburger-Noether data a posteriori without having
          to do all the previous calculation once again (0 if not needed).
 @end table
@@ -2708 +2708 @@
          If the computation of the HNE required a field extension, the first
          entry @code{L[1]} of the list is a ring, in which a list @code{hne}
-         of lists (the HN data, as above) and a poly @code{f} (image of 
-         @code{f} over the new field) are stored. 
+         of lists (the HN data, as above) and a poly @code{f} (image of
+         @code{f} over the new field) are stored.
          @*
-         If called with an additional input parameter, @code{hnexpansion} 
-         computes only one representative for each class of conjugate 
-         branches (over the ground field active when calling the procedure). 
-         In this case, the returned list @code{L} always has only two 
-         entries: @code{L[1]} is either a list of lists (the HN data) or a 
+         If called with an additional input parameter, @code{hnexpansion}
+         computes only one representative for each class of conjugate
+         branches (over the ground field active when calling the procedure).
+         In this case, the returned list @code{L} always has only two
+         entries: @code{L[1]} is either a list of lists (the HN data) or a
          ring (as above), and @code{L[2]} is an integer vector (the number
          of branches in the respective conjugacy classes).
 
 NOTE:    If f is known to be irreducible as a power series, @code{develop(f)}
-         could be chosen instead to avoid a change of basering during the 
+         could be chosen instead to avoid a change of basering during the
          computations. @*
          Increasing  @code{printlevel} leads to more and more comments. @*
@@ -2730 +2730 @@
 "
 {
- int essential; 
+ int essential;
  if (size(#)==1) { essential=1; }
  int field_ext;
@@ -2773 +2773 @@
  // -----                display the multsequence in a nice way
  if (size(hne)>2)
- {  
+ {
    int i,j,k,m;
    list dummy;
@@ -2781 +2781 @@
    for (i=1;i<no_br;i++)
    {
-     for (j=i+1;j<=no_br;j++)  
-     { 
+     for (j=i+1;j<=no_br;j++)
+     {
        nbhd[i,j]=separateHNE(hne[i],hne[j]);
        k=i+1;
@@ -2789 +2789 @@
          k++;
        }
-       if (k<j)  // branches have to be resorted 
+       if (k<j)  // branches have to be resorted
        {
          dummy=hne[j];
@@ -2805 +2805 @@
  }
  // -----
- 
+
  if (field_ext==1) {
    dbprint(printlevel-voice+3,"
 // 'hnexpansion' created a list of one ring.
-// To see the ring and the data stored in the ring, type (if you assigned 
-// the name L to the list): 
+// To see the ring and the data stored in the ring, type (if you assigned
+// the name L to the list):
      show(L);
-// To display the computed HN expansion, type 
+// To display the computed HN expansion, type
      def HNring = L[1]; setring HNring;  displayHNE(hne); ");
    if (essential==1) {
      dbprint(printlevel-voice+3,""+
-"// As second entry of the returned list L, you obtain an integer vector, 
+"// As second entry of the returned list L, you obtain an integer vector,
 // indicating the number of conjugates for each of the computed branches.");
      return(list(HNEring,hne_conj));
-   }   
+   }
    return(list(HNEring));
  }
@@ -2832 +2832 @@
      kill mmm,HNhelpring;
    }
-   else {   
+   else {
      list hne=fetch(HNEring,hne);
    }
@@ -2866 +2866 @@
   basering;
   setring r; kill R;
-  
+
   // Computing only one representative per conjugacy class:
   L=hnexpansion((x4-y6)*(y2+x4),"ess");
@@ -2881 +2881 @@
                second entry = 0  if no change of base ring necessary
                               1  if change of base ring necessary
-               third entry = numbers of conjugates ( if essential = 1 ) 
+               third entry = numbers of conjugates ( if essential = 1 )
         if some error has occured, the empty list is returned
-" 
+"
 {
  def altring = basering;
@@ -2925 +2925 @@
      "// ** WARNING: Algebraic extension of given ground field not possible!";
      "// ** We try to develop this polynomial, but if the need for a field";
-     "// ** extension occurs during the calculation, we cannot proceed with"; 
+     "// ** extension occurs during the calculation, we cannot proceed with";
      "// ** the corresponding branches.";
      execute("ring HNEring=("+charstr(basering)+"),(x,y),ls;");
@@ -2960 +2960 @@
    }
  }
- 
+
  if (defined(HNDebugOn))
  {"received polynomial: ",f,", with x =",namex,", y =",namey;}
@@ -2967 +2967 @@
  int Abbruch,i,NullHNEx,NullHNEy;
  string str;
- list Newton,hne; 
+ list Newton,hne;
 
  // --- changed for SINGULAR 3: ---
@@ -3147 +3147 @@
 
  //----- hier steht die Anzahl bisher benoetigter Ringerweiterungen drin: -----
- int EXTHNEnumber=0; 
+ int EXTHNEnumber=0;
 
  list EXTHNEring;
@@ -3162 +3162 @@
  if (grenze1>0) {
   if (EXTHNEnumber>0){ EXTHNEring = EXTHNEring(1..EXTHNEnumber); }
-  HNE_RingDATA = list(HNEring, HNE_noparam, EXTHNEnumber, EXTHNEring, 
-                      number_of_letztring); 
+  HNE_RingDATA = list(HNEring, HNE_noparam, EXTHNEnumber, EXTHNEring,
+                      number_of_letztring);
 
   list hilflist=HN(HNE_RingDATA,f,grenze1,1,essential,0,hne_conj,1);
@@ -3186 +3186 @@
      if (not(defined(f))) {poly f; f=hole(f); export f;}
      else                 {f=hole(f);}
-  } 
+  }
   number_of_letztring = hilflist[2];
-  kill hilflist; 
+  kill hilflist;
  }
 
@@ -3210 +3210 @@
 
   HNE_RingDATA = list(HNEring, HNE_noparam, EXTHNEnumber, EXTHNEring,
-                      number_of_letztring); 
+                      number_of_letztring);
   list hilflist=HN(HNE_RingDATA,xytausch(f),grenze2,1,essential,1,hne_conj,1);
   kill HNEring, HNE_noparam;
@@ -3219 +3219 @@
   for (i=1; i<=EXTHNEnumber; i++) { def EXTHNEring(i)=hilflist[1][4][i]; }
   if (hilflist[2]==0) { setring HNEring; number_of_letztring=0; }
-  else                { setring EXTHNEring(hilflist[2]); 
+  else                { setring EXTHNEring(hilflist[2]);
                         number_of_letztring=hilflist[2]; }
   if (hilflist[3]==1){field_ext=1;}
@@ -3234 +3234 @@
 
  // --- aufraeumen ---
- if (defined(HNEakut)){ 
+ if (defined(HNEakut)){
    kill HNEakut,faktoren,deltais,transformiert,teiler,leitf;
  }
@@ -3264 +3264 @@
 ///////////////////////////////////////////////////////////////////////////////
 static proc HN (list HNE_RingDATA,poly fneu,int grenze,Aufruf_Ebene,
-                     essential,getauscht,intvec hne_conj,int conj_factor)  
+                     essential,getauscht,intvec hne_conj,int conj_factor)
 "NOTE: This procedure is only for internal use, it is called via pre_HN
-RETURN: list: first entry = list of HNErings, 
+RETURN: list: first entry = list of HNErings,
               second entry = number of new base ring (0 for HNEring,
                                                       -1 for HNE_noparam,
@@ -3290 +3290 @@
  int number_of_letztring = HNE_RingDATA[5];
  if (defined(basering))
- { 
+ {
    if (number_of_letztring==0) { kill HNEring; def HNEring=basering; }
-   else                 { kill EXTHNEring(number_of_letztring); 
+   else                 { kill EXTHNEring(number_of_letztring);
                           def EXTHNEring(number_of_letztring)=basering; }
  }
@@ -3298 +3298 @@
  {
    if ( number_of_letztring==0) { setring HNEring; }
-   else                         { setring EXTHNEring(number_of_letztring); } 
+   else                         { setring EXTHNEring(number_of_letztring); }
  }
  if (not(defined(hne))) {list hne;}
@@ -3376 +3376 @@
            // voice abzufragen macht bei rekursiven procs keinen Sinn
         azeilen[zeile+1][Q+1]=x;
-        //----- Q wird nur in hqs eingetragen, wenn der Spezialfall nicht 
+        //----- Q wird nur in hqs eingetragen, wenn der Spezialfall nicht
         //      eintritt (siehe unten) -----
         Abbruch=2;
@@ -3388 +3388 @@
            // Wir haben das Problem, dass die HNE eines Zweiges hier abbricht,
            // aber ein anderer Zweig bis hierher genau die gleiche HNE hat, die
-           // noch weiter geht 
-           // Loesung: mache Transform. rueckgaengig und behandle fneu im 
+           // noch weiter geht
+           // Loesung: mache Transform. rueckgaengig und behandle fneu im
            // Verzweigungsteil
            //------------------------------------------------------------------
@@ -3415 +3415 @@
   list faktoren;
   ideal deltais;
-  list HNEakut=ideal(0);  
+  list HNEakut=ideal(0);
   intvec eis;
   int zaehler,hnezaehler,zl,zl1,M1,N1,R1,Q1,needext;
@@ -3430 +3430 @@
   //======= Schleife fuer jede zu betrachtende Seite des Newtonpolygons: ======
   for(i=zeiger; i<size(Newton); i++) {
-   if ((essential==1) and (EXTHNEnumber>number_of_letztring)) { 
+   if ((essential==1) and (EXTHNEnumber>number_of_letztring)) {
      // ----- setze ring zurueck fuer neue Kante  -----
      // ---- (damit konjugierte Zweige erkennbar) -----
@@ -3439 +3439 @@
      setring SaveRing;
      if (not(defined(HNEs))) { // HN wurde zum 2.Mal von pre_HN aufgerufen
-       list HNEs=ideal(0); 
+       list HNEs=ideal(0);
      }
      for (k=number_of_letztring+1; k<=EXTHNEnumber; k++) { kill EXTHNEring(k);}
-     EXTHNEnumber=number_of_letztring;    
+     EXTHNEnumber=number_of_letztring;
      if (EXTHNEnumber==0) { setring HNEring; }
      else                 { setring EXTHNEring(EXTHNEnumber); }
@@ -3470 +3470 @@
    for (numberofRingchanges=1; needext==1; numberofRingchanges++) {
     leitf=redleit(fneu,Newton[i],Newton[i+1])/
-                     (x^Newton[i][1]*y^Newton[i+1][2]); 
+                     (x^Newton[i][1]*y^Newton[i+1][2]);
     delt=factorfirst(leitf,M,N);
     needext=0;
@@ -3476 +3476 @@
      //---------- Sonderbehandlung: faktorisiere einige Polynome ueber Q(a): --
      if ((charstr(basering)=="0,a") and (essential==0)) {
-        faktoren=factorize(charPoly(leitf,M,N));  
+        faktoren=factorize(charPoly(leitf,M,N));
         conjugates=1;
         for (k=2;k<=size(faktoren[2]);k++) {conjugates=conjugates,1;}
@@ -3499 +3499 @@
              for (k=2;k<=size(hilf_id);k++) {
                dd=dd+deg(hilf_id[k]);
-               if (deg(hilf_id[k])<deg(fac)) { fac=hilf_id[k]; } 
+               if (deg(hilf_id[k])<deg(fac)) { fac=hilf_id[k]; }
              }
              faktoren[1][zaehler]=fac;
-             kill fac; 
-             conjugates[zaehler]=conj_factor*dd; 
+             kill fac;
+             conjugates[zaehler]=conj_factor*dd;
            }
-           else { 
-             faktoren[1][zaehler]=hilf_id[1]; 
-             conjugates[zaehler]=conj_factor; 
+           else {
+             faktoren[1][zaehler]=hilf_id[1];
+             conjugates[zaehler]=conj_factor;
            }
          }
@@ -3548 +3548 @@
       }
       if (parstr(basering)=="") {
-        EXTHNEnumber++; 
+        EXTHNEnumber++;
         def EXTHNEring(EXTHNEnumber) = splitring(zerlege);
         setring EXTHNEring(EXTHNEnumber);
@@ -3555 +3555 @@
         poly transfproc=0;
         ring_changed=1;
-        export transfproc; 
+        export transfproc;
       }
       else {
         if (numberofRingchanges>1) {  // ein Ringwechsel hat nicht gereicht
-         def helpring = splitring(zerlege,list(transf,transfproc,faktoren)); 
+         def helpring = splitring(zerlege,list(transf,transfproc,faktoren));
          kill EXTHNEring(EXTHNEnumber);
          def EXTHNEring(EXTHNEnumber)=helpring;
@@ -3594 +3594 @@
       }
       //-----------------------------------------------------------------------
-      // transf enthaelt jetzt den alten Parameter des Ringes, der aktiv war 
-      // vor Beginn der Schleife (evtl. also ueber mehrere Ringwechsel 
-      // weitergereicht), 
-      // transfproc enthaelt den alten Parameter des Ringes, der aktiv war zu 
+      // transf enthaelt jetzt den alten Parameter des Ringes, der aktiv war
+      // vor Beginn der Schleife (evtl. also ueber mehrere Ringwechsel
+      // weitergereicht),
+      // transfproc enthaelt den alten Parameter des Ringes, der aktiv war zu
       // Beginn der Prozedur, und der an die aufrufende Prozedur zurueckgegeben
-      // werden muss 
+      // werden muss
       // transf ist Null, falls der alte Ring keinen Parameter hatte,
       // das gleiche gilt fuer transfproc
@@ -3622 +3622 @@
       if (not defined(faktoren)) {list faktoren; }
       faktoren=imap(letztring,faktoren);
-        
+
       if (not(defined(azeilen))){list azeilen,HNEs;}
       azeilen=imap(letztring,azeilen);
@@ -3638 +3638 @@
         poly f=hole(f);
         list hne=hole(hne);
-        export f,hne;      
+        export f,hne;
       }
     }
@@ -3665 +3665 @@
    //============ Schleife fuer jeden gefundenen Faktor der Leitform: =========
    for (j=1; j<=size(eis); j++) {
-     //---- Mache Transformation T1 oder T2, trage Daten in HNEs ein, 
+     //---- Mache Transformation T1 oder T2, trage Daten in HNEs ein,
      //     falls HNE abbricht: ----
 
@@ -3710 +3710 @@
        // Werte von:  zeile: aktuelle Zeilennummer der HNE (gemeinsamer Teil)
        //             zl : die HNE spaltet auf; zeile+zl ist der Index fuer die
-       //                  Zeile des aktuellen Zweigs; (zeile+zl-2) ist die 
-       //                  tatsaechl. Zeilennr. (bei 0 angefangen) der HNE  
+       //                  Zeile des aktuellen Zweigs; (zeile+zl-2) ist die
+       //                  tatsaechl. Zeilennr. (bei 0 angefangen) der HNE
        //                  ([1] <- intvec(hqs), [2] <- 0. Zeile usw.)
        //----------------------------------------------------------------------
@@ -3757 +3757 @@
 
      if (EXTHNEnumber>0){ EXTHNEring = EXTHNEring(1..EXTHNEnumber); }
-     HNE_RingDATA = list( HNEring, HNE_noparam, EXTHNEnumber, EXTHNEring, 
-                          lastRingnumber); 
+     HNE_RingDATA = list( HNEring, HNE_noparam, EXTHNEnumber, EXTHNEring,
+                          lastRingnumber);
      if (defined(HNerg)) {kill HNerg;}
      list HNerg=HN(HNE_RingDATA,transformiert,eis[j],Aufruf_Ebene+1,
-                                essential,getauscht,hne_conj,conj2[j]);    
+                                essential,getauscht,hne_conj,conj2[j]);
      HNE_RingDATA = HNerg[1];
      if (conj1==0) { conj1=HNerg[5]; }
@@ -3775 +3775 @@
           {" ring change in HN(",Aufruf_Ebene+1,") detected";}
        EXTHNEnumber = HNerg[1][3];
-       for (i=lastRingnumber+1; i<=EXTHNEnumber; i++) { 
-         def EXTHNEring(i)=HNerg[1][4][i]; 
-       } 
+       for (i=lastRingnumber+1; i<=EXTHNEnumber; i++) {
+         def EXTHNEring(i)=HNerg[1][4][i];
+       }
        if (HNerg[2]==0) { setring HNEring; }
        else             { setring EXTHNEring(HNerg[2]); }
@@ -3784 +3784 @@
        kill tempRing;
 
-       //--- stelle lokale Variablen im neuen Ring wieder her, und rette 
+       //--- stelle lokale Variablen im neuen Ring wieder her, und rette
        //    gegebenenfalls ihren Inhalt: ----
        list erg,faktoren,HNEakut;
-       ideal hilfid;      
+       ideal hilfid;
        erg=ideal(0); faktoren=erg; HNEakut=erg;
        poly leitf,teiler,transformiert;
@@ -3816 +3816 @@
        poly fneu=hole(fneu);
        if (not(defined(f)))
-       { 
+       {
          poly f=hole(f);
          list hne=hole(hne);
@@ -3827 +3827 @@
        HNEs,hnezaehler=constructHNEs(HNEs,hnezaehler,aneu,azeilen,zeile,
                        deltais,Q,j);
-       kill aneu; 
+       kill aneu;
      }
      else {
@@ -3859 +3859 @@
        }
        HNEakut[zeile+zl]=hilfid;
-       // ------ vorher HNEs[.][zeile+zl]<-aneu[.][2], 
+       // ------ vorher HNEs[.][zeile+zl]<-aneu[.][2],
        //        jetzt [zeile+zl+1] <- [3] usw.: --------
        for (zl1=3; zl1<=size(aneu[zaehler]); zl1++) {
@@ -3890 +3890 @@
        setring HNE_noparam;
        if (not(defined(a_x))){ map a_x,a_y; poly mp_save, mp_new; }
-       mp_save=imap(SaveRing,miniPol); 
-       mp_new=imap(EXTHNEring(EXTHNEnumber-1),miniPol); 
+       mp_save=imap(SaveRing,miniPol);
+       mp_new=imap(EXTHNEring(EXTHNEnumber-1),miniPol);
        if (mp_save==mp_new) { // Sonderfall: wieder gleicher Ring
          def EXTHNEring(EXTHNEnumber)=SaveRing;
@@ -3901 +3901 @@
          HNEs[size(HNEs)+1..size(HNEs)+size(dummyL)]=dummyL[1..size(dummyL)];
          kill dummyL,SaveRing;
-       } 
+       }
        else { // verschiedene Ringe
          a_x=HNE_noparam,x,0,0;
@@ -3912 +3912 @@
          poly fac=Lfac[1][1];
          for (k=2;k<=size(Lfac[1]);k++) {
-           if (deg(Lfac[1][k])<deg(fac)) { fac=Lfac[1][k]; } 
+           if (deg(Lfac[1][k])<deg(fac)) { fac=Lfac[1][k]; }
          }
 
@@ -3937 +3937 @@
            kill erg;
            setring HNE_noparam;
-           if (not(defined(HNEs1))) { list HNEs1=ideal(0); } 
+           if (not(defined(HNEs1))) { list HNEs1=ideal(0); }
            HNEs1=imap(EXTHNEring(EXTHNEnumber-1),HNEs);
-           if (not(defined(hne))) { list hne=ideal(0); } 
+           if (not(defined(hne))) { list hne=ideal(0); }
            hne=imap(SaveRing,hne);
            HNEs=imap(SaveRing,HNEs);
@@ -3945 +3945 @@
            map hole=HNE_noparam,transf,x,y;
            poly fneu=hole(fneu);
-           poly f=hole(f); 
+           poly f=hole(f);
            map phi=HNE_noparam,transb,x,y;
            list HNEs=hole(HNEs);
@@ -3958 +3958 @@
      }
      else { // nur bei letzter Kante muss was getan werden
-       if (i==size(Newton)-1) { 
+       if (i==size(Newton)-1) {
          EXTHNEnumber++;
          if (number_of_letztring==0) { def letztring=HNEring; }
          else       { def letztring=EXTHNEring(EXTHNEnumber); }
-         if (minpoly==0) { 
+         if (minpoly==0) {
            def EXTHNEring(EXTHNEnumber)=SaveRing;
            setring EXTHNEring(EXTHNEnumber);
@@ -3973 +3973 @@
          else { // muessen Daten nach SaveRing uebertragen;
            setring HNE_noparam;
-           if (not(defined(HNEs))) { list HNEs; } 
+           if (not(defined(HNEs))) { list HNEs; }
            HNEs=imap(letztring,HNEs);
            def EXTHNEring(EXTHNEnumber)=SaveRing;
@@ -3988 +3988 @@
      }
    }
-   // -----------------end of new part (loop for essential=1) ---------------- 
+   // -----------------end of new part (loop for essential=1) ----------------
   } // end (Loop uber Kanten)
   if (defined(SaveRing)) { kill SaveRing; }
@@ -3995 +3995 @@
   HNEs[1]=list(hqs)+azeilen+list(fneu); // fneu ist transform. Poly oder Null
   conj1[1]=conj_factor;
- } 
+ }
 
  if (Aufruf_Ebene == 1)
  {
    if ((number_of_letztring!=EXTHNEnumber) and (not(defined(hne))))
-   { 
+   {
      //----- falls Zweige in transz. Erw. berechnet werden konnten ---------
-     if (defined(transfproc)) 
+     if (defined(transfproc))
      { // --- Ringwechsel hat stattgefunden ---
        if (defined(HNDebugOn)) {" ring change in HN(",1,") detected";}
@@ -4029 +4029 @@
  }
  else
- { // HN wurde rekursiv aufgerufen 
+ { // HN wurde rekursiv aufgerufen
    if (number_of_letztring!=EXTHNEnumber)
    { // Ringwechsel hatte stattgefunden
      string mipl_alt = string(minpoly);
      execute("ring tempRing = ("+charstr(basering)+"),("+varstr(basering)+
-                              "),("+ordstr(basering)+");"); 
+                              "),("+ordstr(basering)+");");
      execute("minpoly="+ mipl_alt +";");
      list HNEs=imap(EXTHNEring(EXTHNEnumber),HNEs);
      export HNEs;
-     if (defined(HNDebugOn)) {" ! tempRing defined ! ";} 
-   } 
+     if (defined(HNDebugOn)) {" ! tempRing defined ! ";}
+   }
    if (conj1!=0) { hne_conj=conj1; }
    else          { hne_conj=conj_factor; }
@@ -4121 +4121 @@
 {
  int k;
- if ((size(#)>=1) and ((typeof(#[1])=="intvec") or (typeof(#[1])=="int"))) { 
-   int with_conj = 1; intvec C = #[1]; 
- } 
- else { 
-   int with_conj = 0; intvec C = L[2]; 
+ if ((size(#)>=1) and ((typeof(#[1])=="intvec") or (typeof(#[1])=="int"))) {
+   int with_conj = 1; intvec C = #[1];
+ }
+ else {
+   int with_conj = 0; intvec C = L[2];
  }
  // eine Sortierung der Faktoren eruebrigt sich, weil keine zwei versch.
@@ -4209 +4209 @@
          or the list of HN data computed by @code{hnexpansion(f)}.
 RETURN:  int, the delta invariant of the singularity at 0, that is, the vector
-         space dimension of R~/R, (R~ the normalization of the local ring of 
+         space dimension of R~/R, (R~ the normalization of the local ring of
          the singularity.
 NOTE:    In case the Hamburger-Noether expansion of the curve f is needed
@@ -4229 +4229 @@
     else {
       return(delta(L));
-    }  
+    }
   }
   if (typeof(#[1])=="ring") { // INPUT = HNEring of curve
@@ -4235 +4235 @@
     return(delta(hne));
   }
-  if (typeof(#[1])=="matrix")  
-  { // INPUT = hne of an irreducible curve  
+  if (typeof(#[1])=="matrix")
+  { // INPUT = hne of an irreducible curve
     return(invariants(#)[5]/2);
   }
-  else 
+  else
   { // INPUT = hne of a reducible curve
     list INV=invariants(#);