Changeset 2761f3 in git


Ignore:
Timestamp:
Apr 15, 2005, 3:42:55 PM (19 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '3720ae8bfcff4a4649ee98a15552089151d2d59b')
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:
4 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/hnoether.lib

    r7d2f4e r2761f3  
    1 version="$Id: hnoether.lib,v 1.44 2005-04-14 15:39:20 Singular Exp $";
     1-       version="$Id: hnoether.lib,v 1.45 2005-04-15 13:42:53 Singular Exp $";
    22category="Singularities";
    33info="
    4 LIBRARY:  hnoether.lib   Hamburger-Noether (Puiseux) Development
     4LIBRARY:  hnoether.lib   Hamburger-Noether (Puiseux) Expansion
    55AUTHORS:   Martin Lamm,      lamm@mathematik.uni-kl.de
    66           Christoph Lossen, lossen@mathematik.uni-kl.de
     
    1717 hnexpansion(f [,\"ess\"]); Hamburger-Noether (HN) expansion of f
    1818 develop(f [,n]);           HN expansion of irreducible plane curve germs
    19  extdevelop(hne,n);         extension of the H-N development hne of f
    20  param(L [,s]);             parametrization of branches described by HN data
    21  displayHNE(hne);           display HN development as an ideal
     19 extdevelop(hne,n);         extension of the H-N expansion hne of f
     20 param(hne [,s]);           parametrization of branches described by HN data
     21 displayHNE(hne);           display HN expansion as an ideal
    2222 invariants(hne);           invariants of f, e.g. the characteristic exponents
    2323 displayInvariants(hne);    display invariants of f
    2424 multsequence(hne);         sequence of multiplicities
    2525 displayMultsequence(hne);  display sequence of multiplicities
    26  intersection(hne1,hne2);   intersection multiplicity of two curves
    27  is_irred(f);               test if f is irreducible as power series
     26 intersection(hne1,hne2);   intersection multiplicity of two local branches
     27 is_irred(f);               test whether f is irreducible as power series
    2828 delta(f);                  delta invariant of f
    2929 newtonpoly(f);             (local) Newton polygon of f
    30  is_NND(f);                 test if f is Newton non-degenerate
     30 is_NND(f);                 test whether f is Newton non-degenerate
    3131
    3232
     
    917917        @code{extdevelop(develop(f),n)}, or (one entry in) the list of HN
    918918        data created by @code{hnexpansion(f[,\"ess\"])}.
    919 RETURN: a parametrization for f in the following format: @*
     919RETURN: If L are the HN data of an irreducible plane curve singularity f: a
     920        parametrization for f in the following format: @*
    920921        - if only the list L is given, the result is an ideal of two
    921922        polynomials p[1],p[2]: if the HNE was finite then f(p[1],p[2])=0};
     
    927928        l[1] are exact (entry -1 means that the corresponding parametrization
    928929        is exact).
     930        If L collects the HN data of a reducible plane curve singularity f,
     931        the return value is a list of parametrizations in the respective
     932        format.
    929933NOTE:   If the basering has only 2 variables, the first variable is chosen
    930934        as indefinite. Otherwise, the 3rd variable is chosen.
     
    15001504proc intersection (list hn1, list hn2)
    15011505"USAGE:   intersection(hne1,hne2); hne1, hne2 lists
    1502 ASSUME:  hne1, hne2 represent a HNE (i.e., are the output of
    1503         @code{develop(f)}, or of @code{extdevelop(develop(f),n)}, or
    1504         one entry of the list @code{hne} in the ring created by
    1505         @code{hnexpansion(f[,\"ess\"])}).
    1506 RETURN:  int, the intersection multiplicity of the branches corresponding to
    1507          hne1 and hne2.
     1506ASSUME: @code{hne1, hne2} represent an HN expansion of an irreducible plane
     1507        curve singularity (that is, are the output of @code{develop(f)}, or of
     1508        @code{extdevelop(develop(f),n)}, or one entry of the list of HN data
     1509        computed by @code{hnexpansion(f[,\"ess\"])}).
     1510RETURN:  int, the intersection multiplicity of the irreducible plane curve
     1511         singularities corresponding to @code{hne1} and @code{hne2}.
    15081512SEE ALSO: hnexpansion, displayInvariants
    15091513KEYWORDS: intersection multiplicity
     
    19691973         or of @code{hnexpansion(f[,\"ess\"])}, or (one entry in) the list
    19701974         @code{hne} in the ring created by @code{hnexpansion(f[,\"ess\"])}.
    1971 RETURN:  - if only one argument is given, no return value, but
     1975RETURN:  - if only one argument is given and if the input are the HN data
     1976         of an irreducible plane curve singularity, no return value, but
    19721977         display an ideal HNE of the following form:
    19731978     @example
     
    19781983       z(r-1) =   []*z(r)^2+[]*z(r)^3+......
    19791984     @end example
    1980      where @code{x},@code{y} are the first 2 variables of the basering.
    1981      The values of @code{[]} are the coefficients of the Hamburger-Noether
    1982      matrix, the values of @code{<>} are represented by @code{x} in the
    1983      HN-matrix.@*
    1984      - if a second argument is given, create and export a new ring with
    1985      name @code{displayring} containing an ideal @code{HNE} as described
    1986      above.@*
    1987      - if L corresponds to the output of @code{hnexpansion(f[,\"ess\"])}
    1988      or to the list @code{hne} in the ring created by @code{hnexpansion(f[,\"ess\"])},
    1989      @code{displayHNE(L[,n])} shows the HNE's of all branches of f in the form
    1990      described above. The optional parameter is then ignored.
     1985        where @code{x},@code{y} are the first 2 variables of the basering.
     1986        The values of @code{[]} are the coefficients of the Hamburger-Noether
     1987        matrix, the values of @code{<>} are represented by @code{x} in the
     1988        HN matrix.@*
     1989        - if a second argument is given and if the input are the HN data
     1990        of an irreducible plane curve singularity, return a ring containing
     1991        an ideal @code{HNE} as described above.@*
     1992        - if L corresponds to the output of @code{hnexpansion(f)}
     1993        or to the list of HN data computed by @code{hnexpansion(f[,\"ess\"])},
     1994        @code{displayHNE(L[,n])} shows the HNE's of all branches of f in the
     1995        format described above. The optional parameter is then ignored.
    19911996NOTE:  The 1st line of the above ideal (i.e., @code{HNE[1]}) means that
    19921997     @code{y=[]*z(0)^1+...}, the 2nd line (@code{HNE[2]}) means that
     
    20332038 //////////////////////////////////////////////////////////////
    20342039 setring displayring;
    2035  if (size(#) != 0) {
    2036     export displayring;
    2037   }
    20382040 map holematrix=altring,0;        // mappt nur die Monome vom Grad Null
    20392041 matrix m=holematrix(m);
     
    21212123 }
    21222124if (size(#) != 0) {
    2123    "// basering is now 'displayring' containing ideal 'HNE'";
     2125   HNE;
    21242126   export(HNE);
    2125    keepring(displayring);
    2126    return(HNE);
     2127   return(displayring);
    21272128 }
    21282129}
     
    27992800   kill HNEring;
    28002801   if (essential==1) {
    2801      dbprint(printlevel-voice+3,"
    2802 // No change of ring necessary, return value is a list:
     2802     dbprint(printlevel-voice+3,""+
     2803"// No change of ring necessary, return value is a list:
    28032804//   first entry  =  list :  HN expansion of essential branches.
    2804 //   second entry =  intvec: numbers of conjugated branches
    2805      ");
     2805//   second entry =  intvec: numbers of conjugated branches ");
    28062806     return(list(hne,hne_conj));
    28072807   }
    28082808   else {
    2809      dbprint(printlevel-voice+3,"
    2810 // No change of ring necessary, return value is HN expansion.
    2811      ");
     2809     dbprint(printlevel-voice+3,""+
     2810"// No change of ring necessary, return value is HN expansion.");
    28122811     return(hne);
    28132812   }
     
    34143413     delt=0;
    34153414     if (defined(zerlege)) { kill zerlege; }
    3416 "Hier durch gelaufen";
    34173415   }
    34183416
     
    37593757       if (lastRingnumber>0) { def letztring=EXTHNEring(lastRingnumber); }
    37603758       else                  { def letztring=HNEring; }
     3759       if (not defined(HNEs)) {list HNEs;}
    37613760       HNEs=imap(letztring,HNEs);
    37623761       if (not defined(azeilen)) {list azeilen;}
     
    38623861         list dummyL=imap(EXTHNEring(EXTHNEnumber-1),HNEs);
    38633862         if (not(defined(HNEs))) { def HNEs=list(); }
     3863         if ((size(HNEs)==1) and (typeof(HNEs[1])=="ideal")) {HNEs=list();}
    38643864         HNEs[size(HNEs)+1..size(HNEs)+size(dummyL)]=dummyL[1..size(dummyL)];
    38653865         kill dummyL,SaveRing;
     
    41634163 factorlist(L);
    41644164}
     4165
    41654166///////////////////////////////////////////////////////////////////////////////
    41664167
    4167 proc deltaHNE(list hne)
    4168 "USAGE:   deltaHNE(L);  L list
    4169 NOTE:     command is obsolete, use hnexpansion(f,\"ess\") instead.   
    4170 SEE ALSO: delta, deltaLoc
    4171 "
    4172 {
    4173    int i,j,inters;
    4174    int n=size(hne);
    4175    list INV;
    4176    for (i=1;i<=n;i++)
    4177    {
    4178      INV[i]=invariants(hne[i]);
    4179    }
    4180    int del=INV[n][5]/2;
    4181    for(i=1;i<=n-1;i++)
    4182    {
    4183       del=del+INV[i][5]/2;
    4184       for(j=i+1;j<=n;j++)
    4185       {
    4186          inters=inters+intersection(hne[i],hne[j]);
    4187       }
    4188    }   
    4189    return(del+inters);
    4190 }
    4191 
    4192 ///////////////////////////////////////////////////////////////////////////////
    4193 
    41944168proc delta
    4195 "USAGE:  delta(INPUT);  INPUT a polynomial defining an isolated  plane curve
     4169"USAGE:  delta(INPUT);  INPUT a polynomial defining an isolated plane curve
    41964170         singularity at 0, or the Hamburger-Noether expansion thereof, i.e.
    4197          the output of @code{develop(f)}, or the output of @code{hnexpansion(f[,\"ess\"])},
    4198          or (one of the entries of) the list @code{hne} in the ring created
    4199          by @code{hnexpansion(f[,\"ess\"])}.
    4200 RETURN:  the delta invariant of the singularity at 0, the vector space
    4201          dimension of R~/R, where R~ is the normalization of the
    4202          singularity R=basering/f
     4171         the output of @code{develop(f)}, or the output of @code{hnexpansion(f)},
     4172         or the list of HN data computed by @code{hnexpansion(f)}.
     4173RETURN:  int, the delta invariant of the singularity at 0, that is, the vector
     4174         space dimension of R~/R, (R~ the normalization of the local ring of
     4175         the singularity.
    42034176NOTE:    In case the Hamburger-Noether expansion of the curve f is needed
    42044177         for other purposes as well it is better to calculate this first
     
    42104183"
    42114184{
    4212   if (typeof(#[1])=="poly")
    4213   { // INPUT = polynomial defining the curve
    4214     list HNEXPANSION=hnexpansion(#[1]);
    4215     return(delta(HNEXPANSION));
    4216   }
    4217   if (typeof(#[1])=="ring")
    4218   { // INPUT = HNEring of curve
    4219     def r_e_t_t_e_r_i_n_g=basering;
    4220     def H_N_E_RING=#[1];
    4221     setring H_N_E_RING;
    4222     int del=delta(hne);
    4223     setring r_e_t_t_e_r_i_n_g;
    4224     kill H_N_E_RING;   
    4225     return(del);
     4185  if (typeof(#[1])=="poly") { // INPUT = polynomial defining the singularity
     4186    list L=hnexpansion(#[1]);
     4187    if (typeof(L[1])=="ring") {
     4188      def altring = basering;
     4189      def HNring = L[1]; setring HNring;
     4190      return(delta(hne));
     4191    }
     4192    else {
     4193      return(delta(L));
     4194   
     4195  }
     4196  if (typeof(#[1])=="ring") { // INPUT = HNEring of curve
     4197    def HNring = #[1]; setring HNring;
     4198    return(delta(hne));
    42264199  }
    42274200  if (typeof(#[1])=="matrix") 
  • Singular/LIB/paramet.lib

    r7d2f4e r2761f3  
    11// last change:           17.01.2001
    22///////////////////////////////////////////////////////////////////////////////
    3 version="$Id: paramet.lib,v 1.14 2005-01-13 09:42:04 Singular Exp $";
     3version="$Id: paramet.lib,v 1.15 2005-04-15 13:42:54 Singular Exp $";
    44category="Visualization";
    55info="
     
    193193  intvec ov=option(get);
    194194  option(noredefine);
    195   list hn,para;
     195  list L,para;
    196196  if (nvars(basering)==2 and
    197197      (find(ordstr(basering), "ls") > 0 ||
     
    199199       find(ordstr(basering), "lp") > 0))
    200200  {
    201     hn = reddevelop(f);
    202     for (int ii=1; ii<=size(hn); ii++)
    203     {
    204       para[ii]=param(hn[ii]);
    205     }
     201    L = hnexpansion(f);
     202    if (typeof(L[1])=="ring") {
     203      def altring = basering;
     204      def HNring = L[1]; setring HNring;
     205      list P = param(hne);
     206      export P;
     207      option(set,ov);
     208      setring(altring);
     209      return(list(HNring));
     210    }
     211    else {
     212      option(set,ov);
     213      list P = param(L);
     214      return(P);
     215    }   
    206216  }
    207217  else
    208218  {
    209     para[1]=0;
    210   }
    211   keepring basering;
    212   option(set,ov);
    213   return(para);
     219    option(set,ov);
     220    return(list());
     221  }
    214222}
    215223example
  • Singular/LIB/primitiv.lib

    r7d2f4e r2761f3  
    33// This library is for Singular 1.2 or newer
    44
    5 version="$Id: primitiv.lib,v 1.17 2005-04-14 15:39:22 Singular Exp $";
     5version="$Id: primitiv.lib,v 1.18 2005-04-15 13:42:54 Singular Exp $";
    66category="Commutative Algebra";
    77info="
     
    380380{ "EXAMPLE:"; echo = 2;
    381381 ring r=0,(x,y),dp;
    382  splitring(x2-2,"r1");   // change to Q(sqrt(2))
     382 def r1=splitring(x2-2);
     383 setring r1; basering; // change to Q(sqrt(2))
    383384 // change to Q(sqrt(2),sqrt(sqrt(2)))=Q(a) and return the transformed
    384385 // old parameter:
    385  splitring(x2-a,"r2",a);
     386 def r2=splitring(x2-a,a);
     387 setring r2; basering; erg;
    386388 // the result is (a)^2 = (sqrt(sqrt(2)))^2
    387  nameof(basering);
    388  r2;
    389389 kill r1; kill r2;
    390390}
  • Singular/LIB/ring.lib

    r7d2f4e r2761f3  
    11//(GMG, last modified 03.11.95)
    22///////////////////////////////////////////////////////////////////////////////
    3 version="$Id: ring.lib,v 1.19 2005-04-01 11:53:31 Singular Exp $";
     3version="$Id: ring.lib,v 1.20 2005-04-15 13:42:55 Singular Exp $";
    44category="General purpose";
    55info="
     
    2626LIB "inout.lib";
    2727LIB "general.lib";
     28LIB "primdec.lib";
    2829///////////////////////////////////////////////////////////////////////////////
    2930
Note: See TracChangeset for help on using the changeset viewer.