Changeset dd8844 in git for Singular/LIB/hnoether.lib
 Timestamp:
 Feb 23, 2004, 11:22:33 AM (20 years ago)
 Branches:
 (u'spielwiese', 'a719bcf0b8dbc648b128303a49777a094b57592c')
 Children:
 eddef045bdc633c4b35252eac8fe9e064d458ef2
 Parents:
 11dddeb845be5372a213e3a7cf3c1687de482519
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

Singular/LIB/hnoether.lib
r11dddeb rdd8844 1 // last change, ML: 31.08.00 2 /////////////////////////////////////////////////////////////////////////////// 3 // This library is for Singular 137 or newer 4 5 version="$Id: hnoether.lib,v 1.35 20040212 09:47:12 Singular Exp $"; 1 version="$Id: hnoether.lib,v 1.36 20040223 10:22:33 Singular Exp $"; 6 2 category="Singularities"; 7 3 info=" … … 29 25 intersection(hne1,hne2); intersection multiplicity of two curves 30 26 stripHNE(hne); reduce amount of memory consumed by hne 31 is_irred(f); test for irreducibility27 is_irred(f); test if f is irreducible 32 28 delta(f); delta invariant of f 29 newtonpoly(f); (local) Newton polygon of f 30 is_NND(f); test if f is Newton nondegenerate 31 33 32 34 33 AUXILIARY PROCEDURES: … … 45 44 // reddevelop(f); HN development of reducible curves 46 45 // essdevelop(f); HN development of essential branches 47 // deltaHNE(hne); delta invariant of f, hne=reddevelop(f)48 46 // multiplicities(hne); multiplicities of blowed up curves 49 47 … … 52 50 LIB "primitiv.lib"; 53 51 LIB "inout.lib"; 52 LIB "sing.lib"; 54 53 55 54 /////////////////////////////////////////////////////////////////////////////// … … 69 68 The following procedures are also part of `hnoether.lib': 70 69 71 newtonpoly(f); Newton polygon of polynom f72 70 getnm(f); intersection pts. of Newton polygon with axes 73 71 T_Transform(f,Q,N); returns f(y,xy^Q)/y^NQ (f: poly, Q,N: int) … … 236 234 poly f=y22x2y+x6x5y+x4y2; 237 235 T2_Transform(f,1/2,4,1,f); 238 T2_Transform(f,1/2,4,1,referencepoly(newtonpoly(f )));236 T2_Transform(f,1/2,4,1,referencepoly(newtonpoly(f,1))); 239 237 // if size(referencepoly) << size(f) the 2nd example would be faster 240 referencepoly(newtonpoly(f ));238 referencepoly(newtonpoly(f,1)); 241 239 kill exrg; 242 240 } … … 389 387 if (deg(f)>0) { 390 388 g=1; 391 ideal factf=factorize(f,1); 392 for (int i=1; i<=size(factf); i++) { g=g*factf[i]; } 389 //*CL old: ideal factf=factorize(f,1); 390 //* for (int i=1; i<=size(factf); i++) { g=g*factf[i]; } 391 ideal factf=factorize(f)[1]; 392 for (int i=2; i<=size(factf); i++) { g=g*factf[i]; } 393 393 poly testp=squarefree(g); 394 394 if (deg(testp)<deg(g)) { … … 916 916 ASSUME: INPUT is either a bivariate polynomial f defining a plane curve 917 917 singularity, or it is the output of @code{hnexpansion(f[,\"ess\"])}, 918 or it is the outputof @code{develop(f)}, or of @code{extdevelop(develop(f),n)},918 or of @code{develop(f)}, or of @code{extdevelop(develop(f),n)}, 919 919 or the list @{hne} in the ring created by @code{hnexpansion(f)} 920 920 respectively one entry thereof. … … 923 923  if only the list INPUT is given, L[i] is an ideal of two polynomials 924 924 p[1],p[2]: if the HNE of was finite then f[i](p[1],p[2])=0; if not, 925 the \"real\" parametrization will be two power series and p[1],p[2] are 925 the \"real\" parametrization will be two power series and p[1],p[2] are 926 926 truncations of these series.@* 927 927  if the optional parameter x is given, L[i] is itself a list: 928 L[i][1] is the parametrization ideal as above and L[i][2] is an intvec with929 two entries indicating the highest degree up to which the coefficients of930 the monomials in L[i][1] are exact (entry 1 means that the corresponding931 parametrization is exact).928 L[i][1] is the parametrization ideal as above and L[i][2] is an intvec 929 with two entries indicating the highest degree up to which the 930 coefficients of the monomials in L[i][1] are exact (entry 1 means that 931 the corresponding parametrization is exact). 932 932 NOTE: If the basering has only 2 variables, the first variable is chosen 933 933 as indefinite. Otherwise, the 3rd variable is chosen. @* … … 1088 1088 NOTE: If the basering has only 2 variables, the first variable is chosen 1089 1089 as indefinite. Otherwise, the 3rd variable is chosen. 1090 SEE ALSO: develop, extdevelop1090 SEE ALSO: parametrization, develop, extdevelop 1091 1091 KEYWORDS: parametrization 1092 1092 EXAMPLE: example param; shows an example … … 1227 1227 @end format 1228 1228 an empty list, if INPUT contains no valid HNE. 1229 ASSUME: INPUT is bivariate polynomial f or the output of @code{hnexpansion(f[,\"ess\"]) ,1229 ASSUME: INPUT is bivariate polynomial f or the output of @code{hnexpansion(f[,\"ess\"])}, 1230 1230 or the list @code{hne} in the HNEring created by @code{hnexpansion}. 1231 1231 RETURN: list INV, such that INV[i] is the output of @code{invariants(develop(f[i]))} 1232 as above, where f[i] is the ith branch of the curve f, and the last entry1233 contains further invariants of f in the format:1232 as above, where f[i] is the ith branch of the curve f, and the last 1233 entry contains further invariants of f in the format: 1234 1234 @format 1235 1235 INV[i][1] : intvec (characteristic exponents) … … 1570 1570 RETURN: intvec of the different multiplicities that occur when successively 1571 1571 blowingup the curve singularity corresponding to f. 1572 SEE ALSO: develop1572 SEE ALSO: multsequence, develop 1573 1573 EXAMPLE: example multiplicities; shows an example 1574 1574 " … … 1752 1752 "USAGE: multsequence(INPUT); INPUT list or poly 1753 1753 ASSUME: INPUT is the output of @code{develop(f)}, or of @code{extdevelop(develop(f),n)}, 1754 or one entry in the list @code{hne} of the ring created by @code{hnexpansion(f [,\"ess \"])}.1754 or one entry in the list @code{hne} of the ring created by @code{hnexpansion(f)}. 1755 1755 RETURN: intvec corresponding to the multiplicity sequence of (a branch) 1756 1756 of the curve (the same as @code{invariants(INPUT)[6]}). 1757 ASSUME: INPUT is a bivariate polynomial, or the output of @code{hnexpansion(f[,\"ess\"])}, 1758 or the list @code{hne} in the ring created by @code{hnexpansion(f[,\"ess\"])}. 1757 1758 ASSUME: INPUT is a bivariate polynomial, or the output of @code{hnexpansion(f)}, 1759 or the list @code{hne} in the ring created by @code{hnexpansion(f)}. 1759 1760 RETURN: list of two integer matrices: 1760 1761 @texinfo … … 1783 1784 the polynomial itself. 1784 1785 SEE ALSO: displayMultsequence, develop, hnexpansion, separateHNE 1786 KEYWORDS: multiplicity sequence 1785 1787 EXAMPLE: example multsequence; shows an example 1786 1788 " … … 1919 1921 DISPLAY: the sequence of multiplicities: 1920 1922 @format 1921  1923  if @code{INPUT=develop(f)} or @code{INPUT=extdevelop(develop(f),n)} or @code{INPUT=hne[i]}: 1922 1924 @code{a , b , c , ....... , 1} 1923 1925  if @code{INPUT=f} or @code{INPUT=hnexpansion(f[,\"ess\"])} or @code{INPUT=hne}: … … 2236 2238 /////////////////////////////////////////////////////////////////////////////// 2237 2239 2238 proc newtonpoly (poly f )2240 proc newtonpoly (poly f, int #) 2239 2241 "USAGE: newtonpoly(f); f poly 2240 RETURN: list of intvec(x,y) of coordinates of the Newton polygon of f 2241 ASSUME: For performance reasons, newtonpoly assumes that 2242  the basering has ordering `ls' 2243  f(x,0) != 0 != f(0,y), f(0,0) = 0 2242 ASSUME: basering has exactly two variables; @* 2243 f is convenient, that is, f(x,0) != 0 != f(0,y). 2244 RETURN: list of intvecs (= coordinates x,y of the Newton polygon of f). 2245 NOTE: Procedure uses @code{execute}; this can be avoided by calling 2246 @code{newtonpoly(f,1)} if the ordering of the basering is @code{ls}. 2247 KEYWORDS: Newton polygon 2244 2248 EXAMPLE: example newtonpoly; shows an example 2245 2249 " 2246 2250 { 2247 intvec A=(0,ord(subst(f,var(1),0))); 2248 intvec B=(ord(subst(f,var(2),0)),0); 2249 intvec C,H; list L; 2250 int abbruch,i; 2251 poly hilf; 2252 2253 L[1]=A; 2254 // wirf alle Monome auf oder oberhalb der Geraden AB raus:  2255 f=jet(f,A[2]*B[1]1,intvec(A[2],B[1])); 2256 map xytausch=basering,var(2),var(1); 2257 for (i=2; f!=0; i++) { 2258 abbruch=0; 2259 while (abbruch==0) { 2260 // finde den Punkt aus {verbliebene Pkte (a,b) mit a minimal} mit b minimal:  2261 2262 C=leadexp(f); // Ordnung ls ist wesentlich! 2263 2264 if (jet(f,A[2]*C[1]A[1]*C[2]1,intvec(A[2]C[2],C[1]A[1]))==0) 2265 { abbruch=1; } // keine Monome unterhalb der Geraden AC 2266 2267 //  alle Monome auf der Parallelen zur yAchse durch C wegwerfen:  2268 //  (links von C gibt es sowieso keine mehr)  2269 else { f=jet(f,C[1]1,intvec(1,0)); } 2270 } 2271 // finde alle Monome auf der Geraden durch A und C (unterhalb gibt's keine)  2272 hilf=jet(f,A[2]*C[1]A[1]*C[2],intvec(A[2]C[2],C[1]A[1])); 2273 2274 H=leadexp(xytausch(hilf)); 2275 A=H[2],H[1]; 2276 2277 // die Alternative waere ein Ringwechsel nach ..,(y,x),ds gewesen 2278 // A_neu ist der naechste Eckpunkt (unterster Punkt auf Geraden durch A,C) 2279 2280 L[i]=A; 2281 // alle Monome auf oder unterhalb AB raus  2282 f=jet(f,A[2]*B[1]1,intvec(A[2],B[1]A[1])); 2283 } 2284 L[i]=B; 2285 return(L); 2251 if (size(#)>=1) 2252 { 2253 if (typeof(#[1])=="int") 2254 { 2255 // this is done to avoid the "execute" command for procedures in 2256 // hnoether.lib 2257 def is_ls=#[1]; 2258 } 2259 } 2260 if (defined(is_ls)<=0) 2261 { 2262 def @Rold=basering; 2263 execute("ring @RR=("+charstr(basering)+"),("+varstr(basering)+"),ls;"); 2264 poly f=imap(@Rold,f); 2265 } 2266 intvec A=(0,ord(subst(f,var(1),0))); 2267 intvec B=(ord(subst(f,var(2),0)),0); 2268 intvec C,H; list L; 2269 int abbruch,i; 2270 poly hilf; 2271 L[1]=A; 2272 f=jet(f,A[2]*B[1]1,intvec(A[2],B[1])); 2273 if (defined(is_ls)) 2274 { 2275 map xytausch=basering,var(2),var(1); 2276 } 2277 else 2278 { 2279 map xytausch=@RR,var(2),var(1); 2280 } 2281 for (i=2; f!=0; i++) 2282 { 2283 abbruch=0; 2284 while (abbruch==0) 2285 { 2286 C=leadexp(f); 2287 if(jet(f,A[2]*C[1]A[1]*C[2]1,intvec(A[2]C[2],C[1]A[1]))==0) 2288 { 2289 abbruch=1; 2290 } 2291 else 2292 { 2293 f=jet(f,C[1]1,intvec(1,0)); 2294 } 2295 } 2296 hilf=jet(f,A[2]*C[1]A[1]*C[2],intvec(A[2]C[2],C[1]A[1])); 2297 H=leadexp(xytausch(hilf)); 2298 A=H[2],H[1]; 2299 L[i]=A; 2300 f=jet(f,A[2]*B[1]1,intvec(A[2],B[1]A[1])); 2301 } 2302 L[i]=B; 2303 if (defined(is_ls)) 2304 { 2305 return(L); 2306 } 2307 else 2308 { 2309 setring @Rold; 2310 return(L); 2311 } 2286 2312 } 2287 2313 example 2288 { "EXAMPLE:"; 2289 ring @exring_Newt=0,(x,y),ls; 2290 export @exring_Newt; 2291 " ring exring=0,(x,y),ls;"; 2292 echo = 2; 2314 { 2315 "EXAMPLE:"; echo = 2; 2316 ring r=0,(x,y),ls; 2293 2317 poly f=x5+2x3yx2y2+3xy5+y6y7; 2294 2318 newtonpoly(f); 2295 echo = 0; 2296 kill @exring_Newt; 2297 } 2319 } 2320 /////////////////////////////////////////////////////////////////////////////// 2321 2322 proc is_NND (poly f, list #) 2323 "USAGE: is_NND(f[,mu,NP]); f poly, mu int, NP list of intvecs 2324 ASSUME: f is convenient, that is, f(x,0) != 0 != f(0,y);@* 2325 mu (optional) is Milnor number of f.@* 2326 NP (optional) is output of @code{newtonpoly(f)}. 2327 RETURN: int: 1 if f in Newton nondegenerate, 0 otherwise. 2328 SEE ALSO: newtonpoly 2329 KEYWORDS: Newton nondegenerate; Newton polygon 2330 EXAMPLE: example is_NND; shows examples 2331 " 2332 { 2333 int i; 2334 int i_print=printlevelvoice+2; 2335 2336 if (size(#)==0) 2337 { 2338 int mu=milnor(f); 2339 list NP=newtonpoly(f); 2340 } 2341 else 2342 { 2343 if (typeof(#[1])=="int") 2344 { 2345 def mu=#[1]; 2346 def NP=#[2]; 2347 for (i=1;i<=size(NP);i++) 2348 { 2349 if (typeof(NP[i])!="intvec") 2350 { 2351 print("third input cannot be Newton polygon ==> ignored ") 2352 NP=newtonpoly(f); 2353 i=size(NP)+1; 2354 } 2355 } 2356 } 2357 else 2358 { 2359 print("second input cannot be Milnor number ==> ignored ") 2360 int mu=milnor(f); 2361 NP=newtonpoly(f); 2362 } 2363 } 2364 2365 // computation of the Newton number: 2366 int s=size(NP); 2367 int nN=NP[1][2]NP[s][1]+1; 2368 intmat m[2][2]; 2369 for(i=1;i<=s1;i++) 2370 { 2371 m=NP[i+1],NP[i]; 2372 nN=nN+det(m); 2373 } 2374 2375 if(mu==nN) 2376 { // the Newtonpolygon is nondegenerate 2377 return(1); 2378 } 2379 else 2380 { 2381 return(0); 2382 } 2383 } 2384 example 2385 { 2386 "EXAMPLE:"; echo = 2; 2387 ring r=0,(x,y),ls; 2388 poly f=x5+y3; 2389 is_NND(f); 2390 poly g=(xy)^5+3xy5+y6y7; 2391 is_NND(g); 2392 2393 // if already computed, one should give the Minor number and Newton polygon 2394 // as second and third input: 2395 int mu=milnor(g); 2396 list NP=newtonpoly(g); 2397 is_NND(g,mu,NP); 2398 } 2399 2400 2298 2401 /////////////////////////////////////////////////////////////////////////////// 2299 2402 … … 2462 2565 } 2463 2566 else { ideal a=lastrow; } 2464 list Newton=newtonpoly(f );2567 list Newton=newtonpoly(f,1); 2465 2568 int M1=Newton[size(Newton)1][1]; // konstant 2466 2569 number delt; … … 2514 2617 { 2515 2618 if(system("with","Namespaces")) { kill Top::extdguenstig; } 2516 else { kill extdguenstig;}2619 kill extdguenstig; 2517 2620 } 2518 2621 … … 2669 2772 factorfirst(x14+x8y3+y7,14,7); 2670 2773 } 2671 /////////////////////////////////////////////////////////////////////////////// 2672 2774 2775 /////////////////////////////////////////////////////////////////////////////// 2776 // 2777 // the command HNdevelop is obsolete > here is the former help string: 2778 // 2779 /////////////////////////////////////////////////////////////////////////////// 2780 // 2781 //ASSUME: f is a bivariate polynomial (in the first 2 ring variables) 2782 //CREATE: ring with name @code{HNEring}, variables @code{x,y} and ordering 2783 // @code{ls} over a field extension of the current basering's ground 2784 // field. @* 2785 // Since the HamburgerNoether development usually does not exist 2786 // in the originally given basering, @code{HNdevelop} always defines 2787 // @code{HNEring} and CHANGES to it. The field extension is chosen 2788 // minimally. 2789 //RETURN: list @code{L} of lists @code{L[i]} (corresponding to the output of 2790 // @code{develop(f[i])}, f[i] a branch of f, but the last entry being 2791 // omitted). 2792 //@texinfo 2793 //@table @asis 2794 //@item @code{L[i][1]}; matrix: 2795 // Each row contains the coefficients of the corresponding line of the 2796 // HamburgerNoether expansion (HNE) for f[i]. The end of the line is 2797 // marked in the matrix by the first ring variable (usually x). 2798 //@item @code{L[i][2]}; intvec: 2799 // indicating the length of lines of the HNE 2800 //@item @code{L[i][3]}; int: 2801 // 0 if the 1st ring variable was transversal (with respect to f[i]), @* 2802 // 1 if the variables were changed at the beginning of the 2803 // computation, @* 2804 // 1 if an error has occurred. 2805 //@item @code{L[i][4]}; poly: 2806 // the transformed polynomial of f[i] to make it possible to extend the 2807 // HamburgerNoether development a posteriori without having to do 2808 // all the previous calculation once again (0 if not needed) 2809 //@end table 2810 //@end texinfo 2811 //NOTE: @code{HNdevelop} decides which procedure (@code{develop} or 2812 // @code{reddevelop}) applies best to the given problem and calls it. @* 2813 // If f is known to be irreducible as a power series, @code{develop(f)} 2814 // should be chosen instead to avoid the change of basering. @* 2815 // If @code{printlevel>=2} comments are displayed (default is 2816 // @code{printlevel=0}). 2817 // 2818 //EXAMPLE: example HNdevelop; shows an example 2819 // 2673 2820 proc HNdevelop (poly f) 2674 2821 "USAGE: HNdevelop(f); f poly 2675 ASSUME: f is a bivariate polynomial (in the first 2 ring variables) 2676 CREATE: ring with name @code{HNEring}, variables @code{x,y} and ordering 2677 @code{ls} over a field extension of the current basering's ground 2678 field. @* 2679 Since the HamburgerNoether development usually does not exist 2680 in the originally given basering, @code{HNdevelop} always defines 2681 @code{HNEring} and CHANGES to it. The field extension is chosen 2682 minimally. 2683 RETURN: list @code{L} of lists @code{L[i]} (corresponding to the output of 2684 @code{develop(f[i])}, f[i] a branch of f, but the last entry being 2685 omitted). 2686 @texinfo 2687 @table @asis 2688 @item @code{L[i][1]}; matrix: 2689 Each row contains the coefficients of the corresponding line of the 2690 HamburgerNoether expansion (HNE) for f[i]. The end of the line is 2691 marked in the matrix by the first ring variable (usually x). 2692 @item @code{L[i][2]}; intvec: 2693 indicating the length of lines of the HNE 2694 @item @code{L[i][3]}; int: 2695 0 if the 1st ring variable was transversal (with respect to f[i]), @* 2696 1 if the variables were changed at the beginning of the 2697 computation, @* 2698 1 if an error has occurred. 2699 @item @code{L[i][4]}; poly: 2700 the transformed polynomial of f[i] to make it possible to extend the 2701 HamburgerNoether development a posteriori without having to do 2702 all the previous calculation once again (0 if not needed) 2703 @end table 2704 @end texinfo 2705 NOTE: @code{HNdevelop} decides which procedure (@code{develop} or 2706 @code{reddevelop}) applies best to the given problem and calls it. @* 2707 If f is known to be irreducible as a power series, @code{develop(f)} 2708 should be chosen instead to avoid the change of basering. @* 2709 If @code{printlevel>=2} comments are displayed (default is 2710 @code{printlevel=0}). 2711 SEE ALSO: develop, reddevelop, extdevelop, essdevelop, param, displayHNE 2712 EXAMPLE: example HNdevelop; shows an example 2822 NOTE: command is obsolete, use hnexpansion(f) instead. 2823 SEE ALSO: hnexpansion, develop, extdevelop, param, displayHNE 2713 2824 " 2714 2825 { … … 2789 2900 } 2790 2901 } 2791 /////////////////////////////////////////////////////////////////////////////// 2792 2902 2903 /////////////////////////////////////////////////////////////////////////////// 2904 // 2905 // the command reddevelop is obsolete > here is the former help string: 2906 // 2907 /////////////////////////////////////////////////////////////////////////////// 2908 //ASSUME: f is a bivariate polynomial (in the first 2 ring variables) 2909 //CREATE: ring with name @code{HNEring}, variables @code{x,y} and ordering 2910 // @code{ls} over a field extension of the current basering's ground 2911 // field. @* 2912 // Since the HamburgerNoether development of a reducible curve 2913 // singularity usually does not exist in the originally given basering, 2914 // @code{reddevelop} always defines @code{HNEring} and CHANGES to it. 2915 // The field extension is chosen minimally. 2916 //RETURN: list @code{L} of lists @code{L[i]} (corresponding to the output of 2917 // @code{develop(f[i])}, f[i] a branch of f, but the last entry being 2918 // omitted). 2919 //@texinfo 2920 //@table @asis 2921 //@item @code{L[i][1]}; matrix: 2922 // Each row contains the coefficients of the corresponding line of the 2923 // HamburgerNoether expansion (HNE) for f[i]. The end of the line is 2924 // marked in the matrix by the first ring variable (usually x). 2925 //@item @code{L[i][2]}; intvec: 2926 // indicating the length of lines of the HNE 2927 //@item @code{L[i][3]}; int: 2928 // 0 if the 1st ring variable was transversal (with respect to f[i]), @* 2929 // 1 if the variables were changed at the beginning of the 2930 // computation, @* 2931 // 1 if an error has occurred. 2932 //@item @code{L[i][4]}; poly: 2933 // the transformed polynomial of f[i] to make it possible to extend the 2934 // HamburgerNoether development a posteriori without having to do 2935 // all the previous calculation once again (0 if not needed) 2936 //@end table 2937 //@end texinfo 2938 //NOTE: If @code{printlevel>=0} comments are displayed (default is 2939 // @code{printlevel=0}). 2940 // 2941 //EXAMPLE: example reddevelop; shows an example 2942 // 2793 2943 proc reddevelop (poly f) 2794 2944 "USAGE: reddevelop(f); f poly 2795 ASSUME: f is a bivariate polynomial (in the first 2 ring variables) 2796 CREATE: ring with name @code{HNEring}, variables @code{x,y} and ordering 2797 @code{ls} over a field extension of the current basering's ground 2798 field. @* 2799 Since the HamburgerNoether development of a reducible curve 2800 singularity usually does not exist in the originally given basering, 2801 @code{reddevelop} always defines @code{HNEring} and CHANGES to it. 2802 The field extension is chosen minimally. 2803 RETURN: list @code{L} of lists @code{L[i]} (corresponding to the output of 2804 @code{develop(f[i])}, f[i] a branch of f, but the last entry being 2805 omitted). 2806 @texinfo 2807 @table @asis 2808 @item @code{L[i][1]}; matrix: 2809 Each row contains the coefficients of the corresponding line of the 2810 HamburgerNoether expansion (HNE) for f[i]. The end of the line is 2811 marked in the matrix by the first ring variable (usually x). 2812 @item @code{L[i][2]}; intvec: 2813 indicating the length of lines of the HNE 2814 @item @code{L[i][3]}; int: 2815 0 if the 1st ring variable was transversal (with respect to f[i]), @* 2816 1 if the variables were changed at the beginning of the 2817 computation, @* 2818 1 if an error has occurred. 2819 @item @code{L[i][4]}; poly: 2820 the transformed polynomial of f[i] to make it possible to extend the 2821 HamburgerNoether development a posteriori without having to do 2822 all the previous calculation once again (0 if not needed) 2823 @end table 2824 @end texinfo 2825 NOTE: If @code{printlevel>=0} comments are displayed (default is 2826 @code{printlevel=0}). 2827 SEE ALSO: develop, extdevelop, essdevelop, param, displayHNE 2828 EXAMPLE: example reddevelop; shows an example 2945 NOTE: command is obsolete, use hnexpansion(f) instead. 2946 SEE ALSO: hnexpansion, develop, extdevelop, param, displayHNE 2829 2947 " 2830 2948 { … … 2835 2953 "// basering has changed to HNEring"); 2836 2954 } 2955 2956 //  Lossen 10/02 : the branches have to be resorted to be able to 2957 //  display the multsequence in a nice way 2958 if (size(Ergebnis)>2) 2959 { 2960 int i,j,k,m; 2961 list dummy; 2962 int nbsave; 2963 int no_br = size(Ergebnis); 2964 intmat nbhd[no_br][no_br]; 2965 for (i=1;i<no_br;i++) 2966 { 2967 for (j=i+1;j<=no_br;j++) 2968 { 2969 nbhd[i,j]=separateHNE(Ergebnis[i],Ergebnis[j]); 2970 k=i+1; 2971 while ( (nbhd[i,k] >= nbhd[i,j]) and (k<j) ) 2972 { 2973 k++; 2974 } 2975 if (k<j) // branches have to be resorted 2976 { 2977 dummy=Ergebnis[j]; 2978 nbsave=nbhd[i,j]; 2979 for (m=k; m<j; m++) 2980 { 2981 Ergebnis[m+1]=Ergebnis[m]; 2982 nbhd[i,m+1]=nbhd[i,m]; 2983 } 2984 Ergebnis[k]=dummy; 2985 nbhd[i,k]=nbsave; 2986 } 2987 } 2988 } 2989 } 2990 //  2991 2837 2992 keepring basering; 2838 2993 return(Ergebnis); … … 3089 3244 f=f/x; NullHNEx=1; } // x=0 is a solution 3090 3245 3091 Newton=newtonpoly(f );3246 Newton=newtonpoly(f,1); 3092 3247 i=1; Abbruch=0; 3093 3248 // … … 3185 3340 kill EXTHNEnumber; 3186 3341 keepring basering; 3342 3187 3343 return(Ergebnis); 3188 3344 } 3189 3345 3190 3346 /////////////////////////////////////////////////////////////////////////////// 3347 // 3348 // the command essdevelop is obsolete > here is the former help string: 3349 // 3350 /////////////////////////////////////////////////////////////////////////////// 3351 //ASSUME: f is a bivariate polynomial (in the first 2 ring variables) 3352 //CREATE: ring with name @code{HNEring}, variables @code{x,y} and ordering 3353 // @code{ls} over a field extension of the current basering's ground 3354 // field. @* 3355 // Since the HamburgerNoether development of a reducible curve 3356 // singularity usually does not exist in the originally given basering, 3357 // @code{essdevelop} always defines @code{HNEring} and CHANGES to it. 3358 // The field extension is chosen minimally. 3359 //RETURN: list @code{L} of lists @code{L[i]} (corresponding to the output of 3360 // @code{develop(f[i])}, f[i] an \"essential\" branch of f, but the 3361 // last entry being omitted).@* 3362 // For more details type @code{help reddevelop;}. 3363 //NOTE: If the HNE needs a field extension, some of the branches will be 3364 // conjugate. In this case @code{essdevelop} reduces the computation to 3365 // one representative for each group of conjugate branches.@* 3366 // Note that the degree of each branch is in general less than the 3367 // degree of the field extension in which all HNEs can be put.@* 3368 // Use @code{reddevelop} or @code{HNdevelop} to compute a complete HNE, 3369 // i.e., a HNE for all branches.@* 3370 // If @code{printlevel>=0} comments are displayed (default is 3371 // @code{printlevel=0}). 3372 //SEE ALSO: hnexpansion, develop, reddevelop, HNdevelop, extdevelop 3373 //EXAMPLE: example essdevelop; shows an example 3191 3374 proc essdevelop (poly f) 3192 3375 "USAGE: essdevelop(f); f poly 3193 ASSUME: f is a bivariate polynomial (in the first 2 ring variables) 3194 CREATE: ring with name @code{HNEring}, variables @code{x,y} and ordering 3195 @code{ls} over a field extension of the current basering's ground 3196 field. @* 3197 Since the HamburgerNoether development of a reducible curve 3198 singularity usually does not exist in the originally given basering, 3199 @code{essdevelop} always defines @code{HNEring} and CHANGES to it. 3200 The field extension is chosen minimally. 3201 RETURN: list @code{L} of lists @code{L[i]} (corresponding to the output of 3202 @code{develop(f[i])}, f[i] an \"essential\" branch of f, but the last 3203 entry being omitted).@* 3204 For more details type @code{help reddevelop;}. 3205 NOTE: If the HNE needs a field extension, some of the branches will be 3206 conjugate. In this case @code{essdevelop} reduces the computation to 3207 one representative for each group of conjugate branches.@* 3208 Note that the degree of each branch is in general less than the degree 3209 of the field extension in which all HNEs can be put.@* 3210 Use @code{reddevelop} or @code{HNdevelop} to compute a complete HNE, 3211 i.e., a HNE for all branches.@* 3212 If @code{printlevel>=0} comments are displayed (default is 3213 @code{printlevel=0}). 3214 SEE ALSO: develop, reddevelop, HNdevelop, extdevelop 3215 EXAMPLE: example essdevelop; shows an example 3376 NOTE: command is obsolete, use hnexpansion(f,\"ess\") instead. 3377 SEE ALSO: hnexpansion, develop, extdevelop, param 3216 3378 " 3217 3379 { … … 3287 3449 // ======================= der unverzweigte Teil: ============================ 3288 3450 while (Abbruch==0) { 3289 Newton=newtonpoly(f );3451 Newton=newtonpoly(f,1); 3290 3452 zeiger=find_in_list(Newton,grenze); 3291 3453 if (Newton[zeiger][2] != grenze) … … 3414 3576 if (delt==0) { 3415 3577 3416 // Sonderbehandlung: faktoris ere einige Polynome ueber Q(a): 3578 // Sonderbehandlung: faktorisiere einige Polynome ueber Q(a):  3417 3579 if (charstr(basering)=="0,a") { 3418 faktoren=factorize(charPoly(leitf,M,N),2); // damit funktion. Bsp. Baladi 5 3580 //*CL old: faktoren=factorize(charPoly(leitf,M,N),2); // damit funktion. Bsp. Baladi 5 3581 faktoren=factorize(charPoly(leitf,M,N)); 3419 3582 } 3420 3583 else { … … 3426 3589 ideal hilf_id; 3427 3590 for (zaehler=1; zaehler<=size(faktoren[1]); zaehler++) { 3428 hilf_id=factorize(faktoren[1][zaehler] ,0)[1];3591 hilf_id=factorize(faktoren[1][zaehler])[1]; 3429 3592 if (size(hilf_id)>1) { faktoren[1][zaehler]=hilf_id[2]; } 3430 3593 else { faktoren[1][zaehler]=hilf_id[1]; } … … 3861 4024 3862 4025 proc deltaHNE(list hne) 4026 "USAGE: deltaHNE(L); L list 4027 NOTE: command is obsolete, use hnexpansion(f,\"ess\") instead. 4028 SEE ALSO: delta, deltaLoc 4029 " 3863 4030 { 3864 4031 int i,j,inters; … … 3886 4053 "USAGE: delta(INPUT); INPUT a polynomial defining an isolated plane curve 3887 4054 singularity at 0, or the HamburgerNoether expansion thereof, i.e. 3888 the output of @code{develop(f)}, or the output of @code{hnexpansion(f[,\"ess\"]) ,4055 the output of @code{develop(f)}, or the output of @code{hnexpansion(f[,\"ess\"])}, 3889 4056 or (one of the entries of) the list @code{hne} in the ring created 3890 by @code{hnexpansion(f[,\"ess\"]) .4057 by @code{hnexpansion(f[,\"ess\"])}. 3891 4058 RETURN: the delta invariant of the singularity at 0, the vector space 3892 4059 dimension of R~/R, where R~ is the normalization of the … … 3896 4063 with the aid of @code{hnexpansion} and use it as input instead of 3897 4064 the polynomial itself. 4065 SEE ALSO: deltaLoc, invariants 4066 KEYWORDS: delta invariant 3898 4067 EXAMPLE: example delta; shows an example 3899 4068 " … … 3939 4108 proc hnexpansion(poly f,list #) 3940 4109 "USAGE: hnexpansion(f); or hnexpansion(f,\"ess\"); f poly 3941 4110 3942 4111 USAGE: hnexpansion(f); f poly 3943 4112 ASSUME: f is a bivariate polynomial (in the first 2 ring variables) … … 3946 4115 since the HamburgerNoether development usually does not exist 3947 4116 in the originally given basering. The field extension is chosen 3948 minimally. 3949 @* 3950 Moreover, in the ring a list @code{hne} of lists @code{hne[i]} is created 3951 (corresponding to the output of @code{develop(f[i])}, f[i] a branch of f, 3952 but the last entry being omitted). 4117 minimally.@* 4118 Moreover, in the ring a list @code{hne} of lists @code{hne[i]} is 4119 created (corresponding to the output of @code{develop(f[i])}, 4120 f[i] a branch of f, but the last entry being omitted). 3953 4121 @texinfo 3954 4122 @table @asis … … 3971 4139 @end texinfo 3972 4140 RETURN: a list, say @code{hn}, containing the created ring 3973 NOTE: to use the ring type: def HNEring=hn[i]; setring HNEring;.4141 NOTE: to use the ring type: @code{def HNEring=hn[i]; setring HNEring;}. 3974 4142 @* 3975 4143 If f is known to be irreducible as a power series, @code{develop(f)} … … 3985 4153 minimally. 3986 4154 @* 3987 Moreover, in the ring a list @code{hne} of lists @code{hne[i]} is created3988 (corresponding to the output of @code{develop(f[i])}, f[i] an \"essential\"3989 branch of f, but the last entry being omitted). See @code{hnexpansion} above3990 for more details.4155 Moreover, in the ring a list @code{hne} of lists @code{hne[i]} is 4156 created (corresponding to the output of @code{develop(f[i])}, f[i] an 4157 \"essential\" branch of f, but the last entry being omitted). See 4158 @code{hnexpansion} above for more details. 3991 4159 RETURN: a list, say @code{hn}, containing the created ring 3992 NOTE: to use the ring type: def hnering=hn[i]; setring hnering;.4160 NOTE: to use the ring type: @code{def hnering=hn[i]; setring hnering;}. 3993 4161 @* 3994 Alternatively you may use the procedure sethnering and type: sethnering(hn); 4162 Alternatively you may use the procedure sethnering and type: 4163 @code{sethnering(hn);} 3995 4164 @* 3996 4165 If the HNE needs a field extension, some of the branches will be … … 4008 4177 { 4009 4178 def rettering=basering; 4179 if (defined(HNEring)) 4180 { 4181 def @HNEring = HNEring; 4182 kill HNEring; 4183 } 4010 4184 if (size(#)==1) 4011 4185 { … … 4020 4194 setring rettering; 4021 4195 kill HNEring; 4196 if (defined(@HNEring)) 4197 { 4198 def HNEring=@HNEring; 4199 export(HNEring); 4200 } 4022 4201 dbprint(printlevelvoice+2," 4023 4202 // 'hnexpansion' created a list containing a ring, which … … 4067 4246 proc sethnering (list L,list #) 4068 4247 "USAGE: sethnering(L[,s]); L list, s string (optional) 4069 ASSUME: L is a list containing a ring (e.g. the output of hnexpansion).4248 ASSUME: L is a list containing a ring (e.g. the output of @code{hnexpansion}). 4070 4249 CREATE: The procedure creates a ring with name given by the optional parameter 4071 4250 s resp. with name hnering, if no optional parameter is given, and 4072 changes your ring to this ring. The new ring will the ring given as4073 the first entry in the list L.4251 changes your ring to this ring. The new ring will be the ring given 4252 as the first entry in the list L. 4074 4253 RETURN: nothing. 4075 4254 SEE ALSO: hnexpansion
Note: See TracChangeset
for help on using the changeset viewer.