Changeset 2761f3 in git

Timestamp:

Apr 15, 2005, 3:42:55 PM (18 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'f875bbaccd0831e36aaed09ff6adeb3eb45aeb94')

Children:

1e79bc42d7e72fcff731d84985f171cf819261b1

Parents:

7d2f4ef4907cd59899fa683b66f5e5b0408d556f

Message:

*lossen/hannes: new hnoether.lib, 3.0 changes


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

Location:

Singular/LIB

Files:

• hnoether.lib (modified) (15 diffs)
• paramet.lib (modified) (3 diffs)
• primitiv.lib (modified) (2 diffs)
• ring.lib (modified) (2 diffs)

Singular/LIB/hnoether.lib

@@ -1 @@
-version="$Id: hnoether.lib,v 1.44 2005-04-14 15:39:20 Singular Exp $";
+-       version="$Id: hnoether.lib,v 1.45 2005-04-15 13:42:53 Singular Exp $";
 category="Singularities";
 info="
-LIBRARY:  hnoether.lib   Hamburger-Noether (Puiseux) Development
+LIBRARY:  hnoether.lib   Hamburger-Noether (Puiseux) Expansion
 AUTHORS:   Martin Lamm,      lamm@mathematik.uni-kl.de
            Christoph Lossen, lossen@mathematik.uni-kl.de
@@ -17 +17 @@
  hnexpansion(f [,\"ess\"]); Hamburger-Noether (HN) expansion of f
  develop(f [,n]);           HN expansion of irreducible plane curve germs
- extdevelop(hne,n);         extension of the H-N development hne of f
- param(L [,s]);             parametrization of branches described by HN data
- displayHNE(hne);           display HN development as an ideal
+ extdevelop(hne,n);         extension of the H-N expansion hne of f
+ param(hne [,s]);           parametrization of branches described by HN data
+ displayHNE(hne);           display HN expansion as an ideal
  invariants(hne);           invariants of f, e.g. the characteristic exponents
  displayInvariants(hne);    display invariants of f
  multsequence(hne);         sequence of multiplicities
  displayMultsequence(hne);  display sequence of multiplicities
- intersection(hne1,hne2);   intersection multiplicity of two curves
- is_irred(f);               test if f is irreducible as power series
+ intersection(hne1,hne2);   intersection multiplicity of two local branches
+ is_irred(f);               test whether f is irreducible as power series
  delta(f);                  delta invariant of f
  newtonpoly(f);             (local) Newton polygon of f
- is_NND(f);                 test if f is Newton non-degenerate
+ is_NND(f);                 test whether f is Newton non-degenerate
 
 
@@ -917 +917 @@
         @code{extdevelop(develop(f),n)}, or (one entry in) the list of HN 
         data created by @code{hnexpansion(f[,\"ess\"])}.
-RETURN: a parametrization for f in the following format: @*
+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};
@@ -927 +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. 
 NOTE:   If the basering has only 2 variables, the first variable is chosen
         as indefinite. Otherwise, the 3rd variable is chosen.
@@ -1500 +1504 @@
 proc intersection (list hn1, list hn2)
 "USAGE:   intersection(hne1,hne2); hne1, hne2 lists
-ASSUME:  hne1, hne2 represent a HNE (i.e., are the output of
-        @code{develop(f)}, or of @code{extdevelop(develop(f),n)}, or
-        one entry of the list @code{hne} in the ring created by
-        @code{hnexpansion(f[,\"ess\"])}).
-RETURN:  int, the intersection multiplicity of the branches corresponding to
-         hne1 and hne2.
+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 
+         singularities corresponding to @code{hne1} and @code{hne2}.
 SEE ALSO: hnexpansion, displayInvariants
 KEYWORDS: intersection multiplicity
@@ -1969 +1973 @@
          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, no return value, but
+RETURN:  - if only one argument is given and if the input are the HN data
+         of an irreducible plane curve singularity, no return value, but
          display an ideal HNE of the following form:
      @example
@@ -1978 +1983 @@
        z(r-1) =   []*z(r)^2+[]*z(r)^3+......
      @end example
-     where @code{x},@code{y} are the first 2 variables of the basering.
-     The values of @code{[]} are the coefficients of the Hamburger-Noether
-     matrix, the values of @code{<>} are represented by @code{x} in the
-     HN-matrix.@*
-     - if a second argument is given, create and export a new ring with
-     name @code{displayring} containing an ideal @code{HNE} as described
-     above.@*
-     - if L corresponds to the output of @code{hnexpansion(f[,\"ess\"])}
-     or to the list @code{hne} in the ring created by @code{hnexpansion(f[,\"ess\"])},
-     @code{displayHNE(L[,n])} shows the HNE's of all branches of f in the form
-     described above. The optional parameter is then ignored.
+        where @code{x},@code{y} are the first 2 variables of the basering.
+        The values of @code{[]} are the coefficients of the Hamburger-Noether
+        matrix, the values of @code{<>} are represented by @code{x} in the
+        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 
+        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 
+        format described above. The optional parameter is then ignored.
 NOTE:  The 1st line of the above ideal (i.e., @code{HNE[1]}) means that
      @code{y=[]*z(0)^1+...}, the 2nd line (@code{HNE[2]}) means that
@@ -2033 +2038 @@
  //////////////////////////////////////////////////////////////
  setring displayring;
- if (size(#) != 0) {
-    export displayring;
-  }
  map holematrix=altring,0;        // mappt nur die Monome vom Grad Null
  matrix m=holematrix(m);
@@ -2121 +2123 @@
  }
 if (size(#) != 0) {
-   "// basering is now 'displayring' containing ideal 'HNE'";
+   HNE;
    export(HNE);
-   keepring(displayring);
-   return(HNE);
+   return(displayring);
  }
 }
@@ -2799 +2800 @@
    kill HNEring;
    if (essential==1) {
-     dbprint(printlevel-voice+3,"
-// No change of ring necessary, return value is a list:
+     dbprint(printlevel-voice+3,""+
+"// No change of ring necessary, return value is a list:
 //   first entry  =  list :  HN expansion of essential branches.
-//   second entry =  intvec: numbers of conjugated branches 
-     ");
+//   second entry =  intvec: numbers of conjugated branches ");
      return(list(hne,hne_conj));
    }
    else {
-     dbprint(printlevel-voice+3,"
-// No change of ring necessary, return value is HN expansion.
-     ");
+     dbprint(printlevel-voice+3,""+
+"// No change of ring necessary, return value is HN expansion.");
      return(hne);
    }
@@ -3414 +3413 @@
      delt=0;
      if (defined(zerlege)) { kill zerlege; }
-"Hier durch gelaufen";
    }
 
@@ -3759 +3757 @@
        if (lastRingnumber>0) { def letztring=EXTHNEring(lastRingnumber); }
        else                  { def letztring=HNEring; }
+       if (not defined(HNEs)) {list HNEs;}
        HNEs=imap(letztring,HNEs);
        if (not defined(azeilen)) {list azeilen;}
@@ -3862 +3861 @@
          list dummyL=imap(EXTHNEring(EXTHNEnumber-1),HNEs);
          if (not(defined(HNEs))) { def HNEs=list(); }
+         if ((size(HNEs)==1) and (typeof(HNEs[1])=="ideal")) {HNEs=list();}
          HNEs[size(HNEs)+1..size(HNEs)+size(dummyL)]=dummyL[1..size(dummyL)];
          kill dummyL,SaveRing;
@@ -4163 +4163 @@
  factorlist(L);
 }
+
 ///////////////////////////////////////////////////////////////////////////////
 
-proc deltaHNE(list hne)
-"USAGE:   deltaHNE(L);  L list
-NOTE:     command is obsolete, use hnexpansion(f,\"ess\") instead.   
-SEE ALSO: delta, deltaLoc
-"
-{
-   int i,j,inters;
-   int n=size(hne);
-   list INV;
-   for (i=1;i<=n;i++)
-   {
-     INV[i]=invariants(hne[i]);
-   }
-   int del=INV[n][5]/2;
-   for(i=1;i<=n-1;i++)
-   {
-      del=del+INV[i][5]/2;
-      for(j=i+1;j<=n;j++)
-      {
-         inters=inters+intersection(hne[i],hne[j]);
-      }
-   }    
-   return(del+inters);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 proc delta
-"USAGE:  delta(INPUT);  INPUT a polynomial defining an isolated  plane curve
+"USAGE:  delta(INPUT);  INPUT a polynomial defining an isolated plane curve
          singularity at 0, or the Hamburger-Noether expansion thereof, i.e.
-         the output of @code{develop(f)}, or the output of @code{hnexpansion(f[,\"ess\"])},
-         or (one of the entries of) the list @code{hne} in the ring created
-         by @code{hnexpansion(f[,\"ess\"])}.
-RETURN:  the delta invariant of the singularity at 0, the vector space
-         dimension of R~/R, where R~ is the normalization of the
-         singularity R=basering/f
+         the output of @code{develop(f)}, or the output of @code{hnexpansion(f)},
+         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 
+         the singularity.
 NOTE:    In case the Hamburger-Noether expansion of the curve f is needed
          for other purposes as well it is better to calculate this first
@@ -4210 +4183 @@
 "
 {
-  if (typeof(#[1])=="poly")
-  { // INPUT = polynomial defining the curve
-    list HNEXPANSION=hnexpansion(#[1]);
-    return(delta(HNEXPANSION));
-  }
-  if (typeof(#[1])=="ring")
-  { // INPUT = HNEring of curve
-    def r_e_t_t_e_r_i_n_g=basering;
-    def H_N_E_RING=#[1];
-    setring H_N_E_RING;
-    int del=delta(hne);
-    setring r_e_t_t_e_r_i_n_g;
-    kill H_N_E_RING;    
-    return(del);
+  if (typeof(#[1])=="poly") { // INPUT = polynomial defining the singularity
+    list L=hnexpansion(#[1]);
+    if (typeof(L[1])=="ring") {
+      def altring = basering;
+      def HNring = L[1]; setring HNring;
+      return(delta(hne));
+    }
+    else {
+      return(delta(L));
+    }  
+  }
+  if (typeof(#[1])=="ring") { // INPUT = HNEring of curve
+    def HNring = #[1]; setring HNring;
+    return(delta(hne));
   }
   if (typeof(#[1])=="matrix")  

Singular/LIB/paramet.lib

@@ -1 +1 @@
 // last change:           17.01.2001
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: paramet.lib,v 1.14 2005-01-13 09:42:04 Singular Exp $";
+version="$Id: paramet.lib,v 1.15 2005-04-15 13:42:54 Singular Exp $";
 category="Visualization";
 info="
@@ -193 +193 @@
   intvec ov=option(get);
   option(noredefine);
-  list hn,para;
+  list L,para;
   if (nvars(basering)==2 and
       (find(ordstr(basering), "ls") > 0 ||
@@ -199 +199 @@
        find(ordstr(basering), "lp") > 0))
   {
-    hn = reddevelop(f);
-    for (int ii=1; ii<=size(hn); ii++)
-    {
-      para[ii]=param(hn[ii]);
-    }
+    L = hnexpansion(f);
+    if (typeof(L[1])=="ring") {
+      def altring = basering;
+      def HNring = L[1]; setring HNring;
+      list P = param(hne);
+      export P;
+      option(set,ov);
+      setring(altring);
+      return(list(HNring));
+    }
+    else {
+      option(set,ov);
+      list P = param(L);
+      return(P);
+    }   
   }
   else
   {
-    para[1]=0;
-  }
-  keepring basering;
-  option(set,ov);
-  return(para);
+    option(set,ov);
+    return(list());
+  }
 }
 example

Singular/LIB/primitiv.lib

@@ -3 +3 @@
 // This library is for Singular 1.2 or newer
 
-version="$Id: primitiv.lib,v 1.17 2005-04-14 15:39:22 Singular Exp $";
+version="$Id: primitiv.lib,v 1.18 2005-04-15 13:42:54 Singular Exp $";
 category="Commutative Algebra";
 info="
@@ -380 +380 @@
 { "EXAMPLE:"; echo = 2;
  ring r=0,(x,y),dp;
- splitring(x2-2,"r1");   // change to Q(sqrt(2))
+ def r1=splitring(x2-2);
+ setring r1; basering; // change to Q(sqrt(2))
  // change to Q(sqrt(2),sqrt(sqrt(2)))=Q(a) and return the transformed
  // old parameter:
- splitring(x2-a,"r2",a);
+ def r2=splitring(x2-a,a);
+ setring r2; basering; erg;
  // the result is (a)^2 = (sqrt(sqrt(2)))^2
- nameof(basering);
- r2;
  kill r1; kill r2;
 }

Singular/LIB/ring.lib

@@ -1 +1 @@
 //(GMG, last modified 03.11.95)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: ring.lib,v 1.19 2005-04-01 11:53:31 Singular Exp $";
+version="$Id: ring.lib,v 1.20 2005-04-15 13:42:55 Singular Exp $";
 category="General purpose";
 info="
@@ -26 +26 @@
 LIB "inout.lib";
 LIB "general.lib";
+LIB "primdec.lib";
 ///////////////////////////////////////////////////////////////////////////////