Changeset baaef9 in git

Timestamp:

Apr 27, 2000, 11:06:09 PM (23 years ago)

Author:

Martin Lamm <lamm@…>

Branches:

(u'spielwiese', 'f6c3dc58b0df4bd712574325fe76d0626174ad97')

Children:

6c2401eac1edf81c43de3aa4cd120cb316da37a1

Parents:

c91f2336478169b176097dcb6efd1ea442bc4513

Message:

* new procedure essdevelop (omits conjugate branches)
* procedure param can now be called with optional 2nd argument


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

File:

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

Singular/LIB/hnoether.lib

@@ -1 @@
-// $Id: hnoether.lib,v 1.18 1999-12-13 15:33:46 obachman Exp $
-// last change:           31.08.99
-///////////////////////////////////////////////////////////////////////////////
-// This library is for Singular 1-3-4 or newer
-
-version="$Id: hnoether.lib,v 1.18 1999-12-13 15:33:46 obachman Exp $";
+// $Id: hnoether.lib,v 1.19 2000-04-27 21:06:09 lamm Exp $
+// last change:           27.04.00
+///////////////////////////////////////////////////////////////////////////////
+// This library is for Singular 1-3-7 or newer
+
+version="$Id: hnoether.lib,v 1.19 2000-04-27 21:06:09 lamm Exp $";
 info="
 LIBRARY:  hnoether.lib   Procedures for the Hamburger-Noether (Puiseux) development
@@ -15 +15 @@
            Algebroid curves in positive characteristic, Lecture Notes in Math.
            813, Springer (1980).
-           The library contains also procedures for computing the (topoligical)
+           The library contains also procedures for computing the (topological)
            numerical invariants of plane curve singularities.
-  
+
 MAIN PROCEDURES:
  HNdevelop(f);       Hamburger-Noether development of f
  develop(f [,n]);    Hamburger-Noether development of irreducible curves
  reddevelop(f);      Hamburger-Noether development of reducible curves
+ essdevelop(f);      Hamburger-Noether development of essential branches
  extdevelop(hne,n);  extension of the Hamburger-Noether development hne of f
- param(hne);         returns a parametrization of f (input=output(develop))
+ param(hne [,x]);    returns a parametrization of f (input=output(develop))
  displayHNE(hne);    display Hamburger-Noether development as an ideal
  invariants(hne);    invariants of f, e.g. the characteristic exponents
@@ -911 +912 @@
 
 proc param
-"USAGE:  param(l) takes the output of develop(f)
+"USAGE:  param(l [,x]) takes the output of develop(f)
         (list l (matrix m, intvec v, int s[,poly g,...]))
         and gives a parametrization for f; the first variable of the active
         ring is chosen as indefinite. If the ring contains more than
         two variables, the 3rd variable is chosen (remember that develop takes
-        the first two variables and therefore the other vars should be unused)
-RETURN: ideal of two polynomials: if the HNE was finite, f(param[1],param[2])
+        the first two variables and therefore the other vars should be unused).
+ @*     x is an optional parameter of any type.
+RETURN: If only the list l is given:
+        ideal of two polynomials: if the HNE was finite, f(param[1],param[2])
         will be  zero. If not, the real parametrization will be
         two power series; then param will return a truncation of these series.
+
+        If the optional parameter x is given:
+        list L with L[1]=param(l) (the ideal containing the parametrization)
+        and L[2]=intvec with two entries indicating the highest degree unto
+        which the coefficients of the monomials in L[1] are exact (a value of
+        -1 is for infinity, i.e. the corresponding polynomial is exact).
 SEE ALSO: develop, extdevelop
 KEYWORDS: parametrization
@@ -927 +936 @@
 {
  //-------------------------- Initialisierungen -------------------------------
- matrix m=#[1];
- intvec v=#[2];
- int switch=#[3];
+ if (typeof(#[1])=="list") {
+   list Li=#[1];
+   matrix m=Li[1];
+   intvec v=Li[2];
+   int switch=Li[3];
+   int return_list=1;
+ }
+ else {
+   matrix m=#[1];
+   intvec v=#[2];
+   int switch=#[3];
+   int return_list=0;
+ }
  if (switch==-1) {
    "An error has occurred in develop, so there is no HNE.";
@@ -987 +1006 @@
  if (switch==0) {
    if (fehler>0) {
-     if (fehlervor>0)
-      { "// ** Warning: result is exact up to order",fehlervor-1,"in",
-        maxideal(1)[1],"and",fehler-1,"in",maxideal(1)[2],"!";}
-     else { "// ** Warning: result is exact up to order",fehler-1,"in",
-        maxideal(1)[2],"!";}}
-   return(ideal(z(2),z(1)));}
+     if (fehlervor>0) {
+       if ((voice==2) && (printlevel > -1)) {
+         "// ** Warning: result is exact up to order",fehlervor-1,"in",
+         maxideal(1)[1],"and",fehler-1,"in",maxideal(1)[2],"!";
+     }}
+     else {
+       if ((voice==2) && (printlevel > -1)) {
+         "// ** Warning: result is exact up to order",fehler-1,"in",
+         maxideal(1)[2],"!";
+     }}
+   }
+   if (return_list==0) { return(ideal(z(2),z(1))); }
+   else   { return(list(ideal(z(2),z(1)),intvec(fehlervor-1,fehler-1))); }
+ }
  else {
    if (fehler>0) {
-     if (fehlervor>0)
-      { "// ** Warning: result is exact up to order",fehler-1,"in",
-        maxideal(1)[1],"and",fehlervor-1,"in",maxideal(1)[2],"!";}
-     else { "// ** Warning: result is exact up to order",fehler-1,"in",
-        maxideal(1)[1],"!";}}
-   return(ideal(z(1),z(2)));}
+     if (fehlervor>0) {
+      if ((voice==2) && (printlevel > -1)) {
+        "// ** Warning: result is exact up to order",fehler-1,"in",
+        maxideal(1)[1],"and",fehlervor-1,"in",maxideal(1)[2],"!";
+     }}
+     else {
+      if ((voice==2) && (printlevel > -1)) {
+        "// ** Warning: result is exact up to order",fehler-1,"in",
+        maxideal(1)[1],"!";
+     }}
+   }
+   if (return_list==0) { return(ideal(z(1),z(2))); }
+   else   { return(list(ideal(z(1),z(2)),intvec(fehler-1,fehlervor-1))); }
+ }
 }
 example
@@ -1018 +1053 @@
  param(hne_extended1);
  param(hne_extended2);
+ param(hne_extended2,0);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -2296 +2332 @@
  //------------------ Aufruf der geeigneten Prozedur --------------------------
    if (irred==0) {
-     list hne=reddevelop(f);
+     list hne=pre_HN(f,0);       // = reddevelop(f);
+     dbprint(printlevel+1,
+        "// result: "+string(size(hne))+" branch(es) successfully computed,",
+        "//         basering has changed to HNEring");
    }
    else {
@@ -2363 +2402 @@
 EXAMPLE: example reddevelop;  shows an example
 "
+{
+ list Ergebnis=pre_HN(f,0);
+ if (size(Ergebnis)>0) {     // otherwise an error may have occurred
+  dbprint(printlevel+1,
+   "// result: "+string(size(Ergebnis))+" branch(es) successfully computed,",
+   "//         basering has changed to HNEring");
+ }
+ keepring basering;
+ return(Ergebnis);
+}
+example
+{
+  // -------- prepare for example ---------
+  if (nameof(basering)=="HNEring") {
+   def rettering=HNEring;
+   kill HNEring;
+  }
+  // ------ the example starts here -------
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),dp;
+  list hne=reddevelop(x4-y6);
+  size(hne);           // i.e. x4-y6 has two branches
+  print(hne[1][1]);    // HN-matrix of 1st branch
+  param(hne[1]);
+  param(hne[2]);
+  displayInvariants(hne);
+  kill HNEring,r;
+  pause("Hit RETURN to continue:");
+  // ----------------- a more interesting example: --------------------
+  ring r = 32003,(x,y),dp;
+  poly f = x25+x24-4x23-1x22y+4x22+8x21y-2x21-12x20y-4x19y2+4x20+10x19y
+          +12x18y2-24x18y-20x17y2-4x16y3+x18+60x16y2+20x15y3-9x16y
+          -80x14y3-10x13y4+36x14y2+60x12y4+2x11y5-84x12y3-24x10y5
+          +126x10y4+4x8y6-126x8y5+84x6y6-36x4y7+9x2y8-1y9;
+  list hne=reddevelop(f);
+  size(hne);
+  print(hne[1][1]);
+  print(hne[4][1]);
+  // a ring change was necessary, a is a parameter
+  HNEring;
+  kill HNEring,r;
+  echo = 0;
+  // --- restore HNEring if previously defined ---
+  if (defined(rettering)) {
+   setring rettering;
+   def HNEring=rettering;
+   export HNEring;
+  }
+}
+///////////////////////////////////////////////////////////////////////////////
+
+static proc pre_HN (poly f, int essential)
+"NOTE: This procedure is only for internal use, it is called via
+      reddevelop or essdevelop"
 {
  def altring = basering;
@@ -2619 +2712 @@
    {"1st step: Treat Newton polygon until height",grenze1;}
  if (grenze1>0) {
-  hilflist=HN(f,grenze1,1);
+  hilflist=HN(f,grenze1,1,essential);
   if (typeof(hilflist[1][1])=="ideal") { hilflist[1]=list(); }
  //- fuer den Fall, dass keine Zweige in transz. Erw. berechnet werden konnten-
@@ -2645 +2738 @@
   if (EXTHNEnumber==0) { setring HNEring; }
   else                 { setring EXTHNEring(EXTHNEnumber); }
-  list hilflist=HN(xytausch(f),grenze2,1);
+  list hilflist=HN(xytausch(f),grenze2,1,essential);
   if (typeof(hilflist[1][1])=="ideal") { hilflist[1]=list(); }
   if (not defined(Ergebnis)) {
@@ -2674 +2767 @@
  kill EXTHNEnumber;
  keepring basering;
+ return(Ergebnis);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+proc essdevelop (poly f)
+"USAGE:   essdevelop(f); f poly
+RETURN:  Hamburger-Noether development of essential branches of f:
+         A list of lists in the form of develop(f)
+         (matrix,intvec,int,poly -- the last int indicating irreducibility is
+         omitted); each entry contains the data for one of the branches of f.
+         For more details type `help develop;'
+CREATE:  a ring with name `HNEring', variables `x,y' and ordering `ls' over
+         a field extension of the current basering's ground field.
+         As the Hamburger-Noether development of a reducible curve normally
+         does not exist in the given basering, @code{essdevelop} always defines
+         HNEring and changes to it. The field extension is chosen minimal.
+NOTE:    If the HNE needs a field extension, some of the branches will be
+         conjugate. In this case @code{essdevelop} reduces the computation to
+         one representative for each group of conjugate branches.
+         Note that the degree of each branch is in general less than the degree
+         of the field extension in which all HNEs can be put.
+
+         Use @code{reddevelop} or @code{HNdevelop} to compute a complete HNE,
+         i.e. a HNE for all branches.
+SEE ALSO: develop, reddevelop, HNdevelop, extdevelop
+EXAMPLE: example essdevelop;  shows an example
+"
+{
+ list Ergebnis=pre_HN(f,1);
  dbprint(printlevel+1,
-   "// result: "+string(size(Ergebnis))+" branch(es) successfully computed,",
-   "//         basering has changed to HNEring");
+    "// result: "+string(size(Ergebnis))+" branch(es) successfully computed;");
+ if (string(minpoly) <> "0") {
+   dbprint(printlevel+1,
+    "// note that conjugate branches are omitted and that the number",
+    "// of branches represented by each remaining one may vary!");
+ }
+ dbprint(printlevel+1,
+    "// basering has changed to HNEring");
+ keepring basering;
  return(Ergebnis);
 }
@@ -2688 +2817 @@
   // ------ the example starts here -------
   "EXAMPLE:"; echo = 2;
-  ring r=0,(x,y),dp;
-  list hne=reddevelop(x4-y6);
-  size(hne);           // i.e. x4-y6 has two branches
-  print(hne[1][1]);    // HN-matrix of 1st branch
-  param(hne[1]);
-  param(hne[2]);
-  displayInvariants(hne);
-  kill HNEring,r;
-  pause("Hit RETURN to continue:");
-  // ----------------- a more interesting example: --------------------
-  ring r = 32003,(x,y),dp;
-  poly f = x25+x24-4x23-1x22y+4x22+8x21y-2x21-12x20y-4x19y2+4x20+10x19y
-          +12x18y2-24x18y-20x17y2-4x16y3+x18+60x16y2+20x15y3-9x16y
-          -80x14y3-10x13y4+36x14y2+60x12y4+2x11y5-84x12y3-24x10y5
-          +126x10y4+4x8y6-126x8y5+84x6y6-36x4y7+9x2y8-1y9;
+  ring r=2,(x,y),dp;
+  poly f=(x4+x2y+y2)*(x3+xy2+y3);
+  // --------- compute all branches: ---------
   list hne=reddevelop(f);
-  size(hne);
-  print(hne[1][1]);
-  print(hne[4][1]);
-  // a ring change was necessary, a is a parameter
-  HNEring;
-  kill HNEring,r;
+  displayHNE(hne);
+  setring r;
+  // --- compute only one of conjugate branches: ---
+  list hne=essdevelop(f);
+  displayHNE(hne);
+  // nr. 1 of essdevelop represents nr. 1 - 3 of reddevelop and
+  // nr. 2 of essdevelop represents nr. 4 + 5 of reddevelop
   echo = 0;
   // --- restore HNEring if previously defined ---
@@ -2718 +2836 @@
   }
 }
+
 ///////////////////////////////////////////////////////////////////////////////
 static
-proc HN (poly f,int grenze, int Aufruf_Ebene)
-"NOTE: This procedure is only for internal use, it is called via reddevelop"
+proc HN (poly f,int grenze, int Aufruf_Ebene, int essential)
+"NOTE: This procedure is only for internal use, it is called via pre_HN"
 {
  //---------- Variablendefinitionen fuer den unverzweigten Teil: --------------
@@ -2880 +2999 @@
      else {
  //------------------ faktorisiere das charakt. Polynom: ----------------------
- // faktoren=factorize(charPoly(leitf,M,N));       wird ersetzt durch:
-       faktoren=factorlist(faktoren);
+       if ((numberofRingchanges==1) or (essential==0)) {
+         faktoren=factorlist(faktoren);
+       }
+       else {     // eliminiere alle konjugierten Nullstellen bis auf eine:
+         ideal hilf_id;
+         for (zaehler=1; zaehler<=size(faktoren[1]); zaehler++) {
+           hilf_id=factorize(faktoren[1][zaehler],0)[1];
+           if (size(hilf_id)>1) { faktoren[1][zaehler]=hilf_id[2]; }
+           else                 { faktoren[1][zaehler]=hilf_id[1]; }
+         }
+       }
      }
 
@@ -3080 +3208 @@
     if (subst(transformiert,y,0)!=0) {
      lastRingnumber=EXTHNEnumber;
-     list HNerg=HN(transformiert,eis[j],Aufruf_Ebene+1);
+     list HNerg=HN(transformiert,eis[j],Aufruf_Ebene+1,essential);
      if (HNerg[2]==-1) {          // kein Ringwechsel in HN aufgetreten
        aneu=HNerg[1];  }