Changeset 45251f2 in git
 Timestamp:
 Sep 29, 1997, 1:30:33 PM (26 years ago)
 Branches:
 (u'spielwiese', '6e12f9861a9fbafef8cfe9d754bf74a7d483a67b')
 Children:
 b9fbf14a29ff5537d7f2de51a649d65742a21e1a
 Parents:
 7a30b9dc3c4269b1a18643775500a7f61dbfeeaa
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

Singular/LIB/classify.lib
r7a30b9 r45251f2 1 // $Id: classify.lib,v 1.1 3 19970926 08:14:35krueger Exp $1 // $Id: classify.lib,v 1.14 19970929 11:30:33 krueger Exp $ 2 2 // 3 3 // A library for the classification of isolated hypersurface singularities … … 34 34 LIB "nflist.lib"; 35 35 LIB "hilbert.lib"; 36 37 /////////////////////////////////////////////////////////////////////////////// 38 // output  39 /////////////////////////////////////////////////////////////////////////////// 40 //============================================================================= 41 // TopLevel Funktion of the ArnoldClassifier. 42 // 36 LIB "elim.lib"; 37 38 /////////////////////////////////////////////////////////////////////////////// 43 39 proc classify (poly f_in) 44 40 USAGE: classify(f); f=poly 45 COMPUTE: Normalform and singularity type of f 46 RETURN: Normalform of f 41 COMPUTE: normal form and singularity type of f with respect to right 42 equivalence, as given in the book "Singularities of differentiables 43 maps, Volume I" by V.I. Arnold, S.M. GuseinZade, A.N. Varchenko 44 RETURN: normal form of f, of type poly 45 REMARK: This version of classify is only alpha. Please send bugs and comments 46 to: "Kai Krueger" <krueger@mathematik.unikl.de> 47 Be shure to have at least Singular version 0.9.3, better 1.0.1 48 NOTE: type init_debug(n); (0 <= n <= 10) in order to get intermediate 49 information, higher values of n give more information. 50 The proc creates several global objects with names all starting with 51 @, hence there should be no name conflicts 47 52 EXAMPLE: example classify; shows an example 48 REMARK: This version of classify is only alpha. 49 Please send bugs and comments to: 50 "Kai Krueger" <krueger@mathematik.unikl.de> 51 NOTE: The procedure init_debug(n); is usefull as tracemode. 52 n may range from 0 to 10, higher values of n give more information. 53 { 54 // or set the shellvariable SG_DEBUG to the debugging level. 55 if(system("version")<922) { 56 "Sorry. You need to have at least Singular version 0.9.2.c" 57 return; 58 } 59 60 def ring_top=basering; 61 // Get characteristics of ring set it as default. 62 if(defined(CharOfRing) == 1) { kill CharOfRing; } 63 int CharOfRing = char(basering); 64 export CharOfRing; 53 54 { 55 // initialisation  56 init_debug(); // initialize trace/debug mode 57 int n = nvars(basering); 58 def ring_top = basering; 59 int show_nf = 1; // return normal form if set to '1' 60 int i; 65 61 66 62 if(checkring()) { return(f_in); } 67 int @show_nf = 1; // return normal form if set to '1'68 69 int @n = nvars(basering);70 71 // Save the name of initial ring72 int @i;73 74 // if trace/debug mode not set, do it!75 init_debug();76 63 77 64 // define new ring 78 if( defined( Rtop) == 1) { killRtop; }79 ring Rtop=char(basering),(x(1..@n)),(c,ds);80 export Rtop;81 82 map @Conv=ring_top,maxideal(1);65 if( defined(@Rtop) == 1) { kill @Rtop; } 66 ring @Rtop=char(basering),(x(1..n)),(c,ds); 67 export @Rtop; 68 69 map conv_ringtop2rtop=ring_top,maxideal(1); 83 70 setring ring_top; 84 71 85 if(defined( ShowPoly) == 1) { kill ShowPoly; }86 map ShowPoly=Rtop,maxideal(1);87 export ShowPoly;88 setring Rtop;72 if(defined(@showpoly) == 1) { kill @showpoly; } 73 map @showpoly=@Rtop,maxideal(1); 74 export @showpoly; 75 setring @Rtop; 89 76 init(); 90 77 91 string RingDisplay = "ring_top";92 export RingDisplay;93 94 string @s1;95 string @s2;96 string @s4;97 @s1,@s2=Klassifiziere(@Conv(f_in));98 // @s1: f nach saemtlichen Koordinatentransformationen99 // @s2: Typ des Polynoms f z.b: E[18]100 @s4 = "poly @f_out="+@s1+";";101 debug_log(10, "S1=", @s1);102 debug_log(10, "S2=", @s2);103 104 if( @s2[1,2]=="f "  @s2[1,4]=="The "  @s2=="Fehler!"  @s2=="A[0]") {105 if( @s2 != "Fehler!") { @s2; }106 if( @s1=="1"  @s2[1,4]=="The "  @s2=="Fehler!" ) {78 string @ringdisplay = "ring_top"; 79 export @ringdisplay; 80 81 string s1; 82 string s2; 83 string s4; 84 s1,s2=Klassifiziere(conv_ringtop2rtop(f_in)); 85 // s1: f nach saemtlichen Koordinatentransformationen 86 // s2: Typ des Polynoms f z.b: E[18] 87 s4 = "poly f_out="+s1+";"; 88 debug_log(10, "S1=", s1); 89 debug_log(10, "S2=", s2); 90 91 if( s2[1,2]=="f "  s2[1,4]=="The "  s2=="Fehler!"  s2=="A[0]") { 92 if( s2 != "Fehler!") { s2; } 93 if(s1=="1"  s2[1,4]=="The "  s2=="Fehler!" ) { 107 94 setring ring_top; 108 95 return(f_in); 109 96 } 110 setring Rtop;111 execute @s4;112 map @ConvUp=Rtop,maxideal(1);97 setring @Rtop; 98 execute s4; 99 map ConvUp=@Rtop,maxideal(1); 113 100 } 114 101 else { 115 102 setring RingB; 116 execute @s4;117 setring Rtop;118 map @ConvUp=RingB,maxideal(1);119 } 120 if( @show_nf==1) {121 poly @f_nf = normalform(@s2);122 for( @i=4;@i<=@n;@i=@i+1) {123 @f_nf = @f_nf + x(@i)^2;124 } 125 if(DeBug>1) { "Normal form NF(f)=", @f_nf; }126 } 127 poly @f_out = @ConvUp(@f_out);128 for( @i=CoRang+1;@i<=@n;@i=@i+1) {129 @f_out = @f_out + x(@i)^2;103 execute s4; 104 setring @Rtop; 105 map ConvUp=RingB,maxideal(1); 106 } 107 if(show_nf==1) { 108 poly f_nf = normalform(s2); 109 for(i=4;i<=n;i=i+1) { 110 f_nf = f_nf + x(i)^2; 111 } 112 if(DeBug>1) { "Normal form NF(f)=", f_nf; } 113 } 114 poly f_out = ConvUp(f_out); 115 for(i=CoRang+1;i<=n;i=i+1) { 116 f_out = f_out + x(i)^2; 130 117 } 131 118 setring ring_top; 132 map @ConvBack=Rtop,maxideal(1);133 134 if( @show_nf == 1) {135 return( @ConvBack(@f_nf));136 } 137 else { return( @ConvBack(@f_out)); }119 map conv_rtop2ringtop=@Rtop,maxideal(1); 120 121 if(show_nf == 1) { 122 return(conv_rtop2ringtop(f_nf)); 123 } 124 else { return(conv_rtop2ringtop(f_out)); } 138 125 } 139 126 example 140 127 {"EXAMPLE"; echo=2; 141 128 ring r=0,(x,y,z),ds; 142 init_debug(2);143 129 poly f=(x2+3y2z)^2+xyz(xy3+x2*z3)^3; 144 poly g=classify(f); 145 } 146 //============================================================================= 147 // Id: Kclass.lib,v 1.12 1997/08/13 17:21:05 krueger Exp 148 //============================================================================= 149 proc Klassifiziere (poly @f) 150 USAGE: Klassifiziere(f); 151 { 152 string @s1; 153 int @cnt; 154 // Warum hier init() noch einmal, keine Ahnung. 155 // Wenn nicht geht's einfach nicht. Hans fragen! 156 init(1); 157 int @n = nvars(basering); // Zahl der Variablen des aktuellen Rings. 158 159 // Define always 'RingDisplay' to be able to run 'Show(f)' 160 if( defined(RingDisplay) == 0) { 161 string RingDisplay; 162 export RingDisplay; 163 } 164 RingDisplay = "setring RingB;"; 165 166 if(defined(SG_Typ) == 1) { kill SG_Typ; } // Typ(s) von f nach Hilbert. 167 string SG_Typ = ""; 168 export SG_Typ; 169 170 // 171 @s1 = "ring RingB="+string(CharOfRing)+",("+A_Z("x", @n)+"),ds;"; 172 execute @s1; // in diesem Ring werden Polynome angezeigt. 173 @s1 = "map ShowPoly=Rtop,"+A_Z("x", @n)+";"; 174 execute @s1; // Hiermit werden Polynome angezeigt. 175 export ShowPoly; 176 setring Rtop; // in den Ausgangsring zurueck. 177 export RingB; 178 179 //=============================================== 180 181 if(jet(@f,0) != 0 ) { 182 if(defined(CoRang) == 0) { int CoRang = CoRangf(@f); } 183 return("1", "f is a unit"); 184 } 185 186 debug_log(1, "Computing Basicinvariants of f ..."); 187 if(defined(Mu) == 1) { kill Mu; } 188 if(defined(K) == 1) { kill K; } 189 if(defined(CoRang) == 1) { kill CoRang; } 190 int K; 191 int Mu; 192 int CoRang; 193 K, Mu, CoRang = basicinvariants(@f); 194 "About the singularity :"; 195 " Milnor number(f) = "+string(Mu); 196 " Corank(f) = "+string(CoRang); 197 " Determinacy <= "+string(K); 198 export CoRang, K, Mu; 199 200 // ideal @Jf = Jf; 201 // if(dim(std(EH(@Jf))) != @n) { return("x(1)","A[0]"); } 202 if( Mu == 0) { 203 CoRang=1; 204 return("x(1)","A[0]"); 205 } 206 207 if(Mu<0) { 208 "The Milnor number of the function is infinite."; 209 "The singularity is not in Arnolds list."; 210 return("", "Fehler!"); 211 } 212 213 @f = jet(@f, K); 214 @s1,@cnt = HKclass(Hilb(@f)); 215 if(@cnt>0) { "Guessing type via Hilbert polynomial: ", @s1; } 216 else { "Hilbert polynomial not recognised. Milnor code = ", Hilb(@f); } 217 ""; 218 "Computing normal form ..."; 219 220 // Einteilung nach Corang 221 if( defined(ShowPhi) == 0) { int ShowPhi = 0; } 222 if(CoRang == 0) { return(Funktion2(@f, CoRang)); } 223 if(CoRang == 1) { return(Funktion2(@f, CoRang)); } 224 if(CoRang == 2) { return(Funktion1bis(@f, CoRang)); } 225 if(CoRang == 3) { return(Funktion1bis(@f, CoRang)); } 226 return(Funktion105(@f, CoRang)); 227 } 228 /////////////////////////////////////////////////////////////////////////////// 229 proc Funktion1bis (poly @f, int corank) 230 USAGE: Funktion1bis(); 231 { // pruefe ob abspaltung von Quadraten noetig, wenn ja tue dies. 232 233 int @n = nvars(basering); 234 string @s1; 235 string @RestRing = nameof(basering); 236 237 if( @n > corank) { 238 "I have to apply the splitting lemma. This will take some time....:)"; 239 poly @g = Morse(@f, K, corank); 240 241 @g = ReOrder(@g); 242 if(defined(PhiG)==1) { kill PhiG; } 243 if(defined(Rrest) == 1) { kill Rrest; } 244 if(defined(ShowPoly) == 1 ) { kill ShowPoly; } 245 if(defined(RingB) == 1) { kill RingB; } 246 247 execute Setring(corank, "Rrest"); 248 export Rrest; 249 @RestRing = nameof(basering); 250 251 map @MapReduce=Rtop,maxideal(1); 252 poly @G = @MapReduce(@g); 253 254 @s1 = "map PhiG=Rtop," + string(maxideal(1));// Konstruiere Id auf r 130 classify(f); 131 init_debug(3); 132 classify(f); 133 } 134 135 /////////////////////////////////////////////////////////////////////////////// 136 proc Klassifiziere (poly f) 137 { 138 // initialisation  139 string s1; 140 int cnt; 141 // init(1); 142 int n = nvars(basering); // Zahl der Variablen des aktuellen Rings. 143 144 // Define always '@ringdisplay' to be able to run 'Show(f)' 145 if( defined(@ringdisplay) == 0) { 146 string @ringdisplay; 147 export @ringdisplay; 148 } 149 @ringdisplay = "setring RingB;"; 150 151 if(defined(SG_Typ) == 1) { kill SG_Typ; } // Typ(s) von f nach Hilbert. 152 string SG_Typ = ""; 153 export SG_Typ; 154 155 execute ("ring RingB="+charstr(basering)+",("+A_Z("x", n)+"),(c,ds);"); 156 execute("map @showpoly=@Rtop,"+A_Z("x", n)+";"); 157 export @showpoly; 158 setring @Rtop; // in den Ausgangsring zurueck. 159 export RingB; 160 161 //=============================================== 162 163 if(jet(f,0) != 0 ) { 164 if(defined(CoRang) == 0) { int CoRang = CoRangf(f); } 165 return("1", "f is a unit"); 166 } 167 168 debug_log(1, "Computing Basicinvariants of f ..."); 169 if(defined(Mu) == 1) { kill Mu; } 170 if(defined(K) == 1) { kill K; } 171 if(defined(CoRang) == 1) { kill CoRang; } 172 int K; 173 int Mu; 174 int CoRang; 175 K, Mu, CoRang = basicinvariants(f); 176 "About the singularity :"; 177 " Milnor number(f) = "+string(Mu); 178 " Corank(f) = "+string(CoRang); 179 " Determinacy <= "+string(K); 180 export CoRang, K, Mu; 181 182 // ideal Jf = Jf; 183 // if(dim(std(EH(Jf))) != n) { return("x(1)","A[0]"); } 184 if( Mu == 0) { 185 CoRang=1; 186 return("x(1)","A[0]"); 187 } 188 189 if(Mu<0) { 190 "The Milnor number of the function is infinite."; 191 "The singularity is not in Arnolds list."; 192 return("", "Fehler!"); 193 } 194 195 f = jet(f, K); 196 s1,cnt = HKclass(Hilb(f)); 197 if(cnt>0) { "Guessing type via Hilbert polynomial: ", s1; } 198 else { "Hilbert polynomial not recognised. Milnor code = ", Hilb(f); } 199 ""; 200 "Computing normal form ..."; 201 202 // Einteilung nach Corang 203 if( defined(ShowPhi) == 0) { int ShowPhi = 0; } 204 if(CoRang == 0) { return(Funktion2(f, CoRang)); } 205 if(CoRang == 1) { return(Funktion2(f, CoRang)); } 206 if(CoRang == 2) { return(Funktion1bis(f, CoRang)); } 207 if(CoRang == 3) { return(Funktion1bis(f, CoRang)); } 208 return(Funktion105(f, CoRang)); 209 } 210 211 /////////////////////////////////////////////////////////////////////////////// 212 proc Funktion1bis (poly @f, int corank) 213 { // pruefe ob abspaltung von Quadraten noetig, wenn ja tue dies. 214 215 int @n = nvars(basering); 216 string @s1; 217 string @RestRing = nameof(basering); 218 219 if( @n > corank) { 220 "I have to apply the splitting lemma. This will take some time....:)"; 221 poly @g = Morse(@f, K, corank); 222 223 @g = ReOrder(@g); 224 if(defined(PhiG)==1) { kill PhiG; } 225 if(defined(Rrest) == 1) { kill Rrest; } 226 if(defined(@showpoly) == 1 ) { kill @showpoly; } 227 if(defined(RingB) == 1) { kill RingB; } 228 229 execute Setring(corank, "Rrest"); 230 export Rrest; 231 @RestRing = nameof(basering); 232 233 map @MapReduce=@Rtop,maxideal(1); 234 poly @G = @MapReduce(@g); 235 236 @s1 = "map PhiG=@Rtop," + string(maxideal(1));// Konstruiere Id auf r 237 execute @s1; 238 export PhiG; 239 240 execute("ring RingB="+charstr(basering)+",("+A_Z("x", corank)+"),(c,ds);"); 241 export RingB; 242 } 243 else { poly @G = @f; } 244 245 setring RingB; 246 @s1 = "map @showpoly=",@RestRing,","+A_Z("x", corank)+";"; 255 247 execute @s1; 256 export PhiG; 257 258 @s1 = "ring RingB=",string(CharOfRing),",("+A_Z("x", corank)+"),ds;"; 248 export @showpoly; 249 @s1 = "setring ",@RestRing,";"; 259 250 execute @s1; 260 export RingB; 261 } 262 else { poly @G = @f; } 263 264 setring RingB; 265 @s1 = "map ShowPoly=",@RestRing,","+A_Z("x", corank)+";"; 266 execute @s1; 267 export ShowPoly; 268 @s1 = "setring ",@RestRing,";"; 269 execute @s1; 270 271 if(defined(PhiG)==0) { 272 map PhiG=basering, maxideal(1); 273 export PhiG; 274 } 275 if(corank == 2) { return(Funktion3(@G, corank)); } 276 if(corank == 3) { return(Funktion50(@G, corank)); } 277 return("","Fehler!"); 278 } 251 252 if(defined(PhiG)==0) { 253 map PhiG=basering, maxideal(1); 254 export PhiG; 255 } 256 if(corank == 2) { return(Funktion3(@G, corank)); } 257 if(corank == 3) { return(Funktion50(@G, corank)); } 258 return("","Fehler!"); 259 } 260 279 261 /////////////////////////////////////////////////////////////////////////////// 280 262 proc Funktion3 (poly @f, int corank); … … 300 282 return("", "Fehler!"); // Should never occur 301 283 } 302 /////////////////////////////////////////////////////////////////////////////// 303 // proc Funktion6  put here284 285 /////////////////////////////////////////////////////////////////////////////// 304 286 proc Funktion6 (poly @f, int corank) 305 287 USAGE: Funktion6() … … 372 354 return("","Fehler!"); 373 355 } 374 /////////////////////////////////////////////////////////////////////////////// 375 //proc Funktion13  put here 376 //========================================================================= 377 // Id: lib_WorkOn,v 1.8 1995/01/27 12:53:11 krueger Exp 378 // 379 /////////////////////////////////////////////////////////////////////////////// 380 // 381 382 //========================================================================= 356 357 /////////////////////////////////////////////////////////////////////////////// 383 358 proc Funktion13 (poly @f, int corank) 384 359 USAGE: Funktion13(); … … 407 382 return("","Fehler!"); 408 383 } 409 /////////////////////////////////////////////////////////////////////////////// 384 410 385 /////////////////////////////////////////////////////////////////////////////// 411 386 proc Funktion17 (poly @f, int corank) … … 458 433 return("","Fehler!"); 459 434 } 435 460 436 /////////////////////////////////////////////////////////////////////////////// 461 437 proc Funktion25 (poly @f, int CoRang) … … 546 522 return("","Fehler!"): 547 523 } 524 548 525 /////////////////////////////////////////////////////////////////////////////// 549 526 proc Funktion40 (poly @f, int @k) 550 527 USAGE: Funktion40(); 551 528 { 552 // poly @f = #[1];553 // int @k = #[2];554 529 int @r; 555 530 string @Typ; … … 630 605 return("","Fehler!"); 631 606 } 632 /////////////////////////////////////////////////////////////////////////////// 633 /////////////////////////////////////////////////////////////////////////////// 634 //proc Funktion50  put here 635 //========================================================================= 636 // Id: lib_WorkOn,v 1.6 1995/08/29 18:04:09 krueger Exp 637 // 638 // Please send bugs and comments to krueger@mathematik.unikl.de 639 // 640 /////////////////////////////////////////////////////////////////////////////// 641 642 LIB "elim.lib"; 643 644 //========================================================================= 607 608 /////////////////////////////////////////////////////////////////////////////// 645 609 proc Funktion50 (poly @f, int corank) 646 610 USAGE: Funktion50(); … … 689 653 return("","Fehler!"); 690 654 } 655 691 656 /////////////////////////////////////////////////////////////////////////////// 692 657 proc Funktion51 (poly @f, int @k) … … 700 665 return(Show(@f), @tp); 701 666 } 667 702 668 /////////////////////////////////////////////////////////////////////////////// 703 669 proc Funktion52 (poly @f, int @k) … … 712 678 return(Show(@f), @tp); 713 679 } 680 714 681 /////////////////////////////////////////////////////////////////////////////// 715 682 proc Funktion54 (poly @f, int @k) … … 724 691 return(Show(@f), @tp); 725 692 } 693 726 694 /////////////////////////////////////////////////////////////////////////////// 727 695 proc Funktion56 (poly @f, int @k) … … 736 704 return(Show(@f), @tp); 737 705 } 706 738 707 /////////////////////////////////////////////////////////////////////////////// 739 708 proc Funktion58 (poly @fin, int @k) … … 1010 979 "nach z:",Show(@fz), " Id=", @JetId, " Dim=", dim(@JetId); 1011 980 } 981 1012 982 /////////////////////////////////////////////////////////////////////////////// 1013 983 proc Funktion82 (poly @f, int @k) … … 1101 1071 return("", "Fehler"); 1102 1072 } 1073 1103 1074 /////////////////////////////////////////////////////////////////////////////// 1104 1075 proc Isomorphie_s82_z (poly @f, poly @fk, int @p) … … 1149 1120 return(@f); 1150 1121 } 1122 1151 1123 /////////////////////////////////////////////////////////////////////////////// 1152 1124 proc Funktion83 (poly @f, int @k) … … 1331 1303 return(Show(@f), "V[k,r]"); 1332 1304 } 1305 1333 1306 /////////////////////////////////////////////////////////////////////////////// 1334 1307 proc Funktion103 (poly @f) … … 1337 1310 return(FunktionNoClass(@f,"3jet = x3")); 1338 1311 } 1312 1339 1313 /////////////////////////////////////////////////////////////////////////////// 1340 1314 proc Funktion104 (poly @f) … … 1343 1317 return(FunktionNoClass(@f)); 1344 1318 } 1319 1345 1320 /////////////////////////////////////////////////////////////////////////////// 1346 1321 proc Funktion105 (poly @f); … … 1349 1324 return(FunktionNoClass(@f)); 1350 1325 } 1326 1351 1327 /////////////////////////////////////////////////////////////////////////////// 1352 1328 proc FunktionNoClass (poly @f, list #) 1353 1329 USAGE: FunktionNoClass(); 1354 1355 1330 { 1356 1331 if(size(#)==2) { string @txt=#[2]; } … … 1363 1338 return(Show(@f), @s); 1364 1339 } 1365 /////////////////////////////////////////////////////////////////////////////// 1340 1366 1341 /////////////////////////////////////////////////////////////////////////////// 1367 1342 proc tschirnhaus (poly @f, poly @x) … … 1392 1367 return(@Phi(@f), @Phi); 1393 1368 } 1394 /////////////////////////////////////////////////////////////////////////////// 1369 1395 1370 /////////////////////////////////////////////////////////////////////////////// 1396 1371 proc Isomorphie_s17 (poly @f, poly @fk, int @k, int @ct) … … 1541 1516 } 1542 1517 1543 //============================================================================= 1544 // Id: Ausgaben.lib,v 1.17 1997/08/13 07:39:04 krueger Exp 1545 /============================================================================= 1546 // 1547 // Please send bugs and comments to krueger@mathematik.unikl.de 1548 // 1549 /////////////////////////////////////////////////////////////////////////////// 1550 // required libraries 1551 1552 /////////////////////////////////////////////////////////////////////////////// 1553 // required by 1554 // LIB "Classify.lib" 1555 // LIB "Kclass.lib" 1556 1557 /////////////////////////////////////////////////////////////////////////////// 1558 proc Funktion2 (poly @f, int corank) 1518 /////////////////////////////////////////////////////////////////////////////// 1519 proc Funktion2 (poly f, int corank) 1559 1520 USAGE: 1560 1521 { 1561 poly @f = #[1];1562 string @s = "The singularity `"+string(Show(@f));1563 string @tp = "A["+string(Mu)+"]"; 1564 1565 @s = @s +"' is Requivalent to "+@tp+".";1566 @s; // +" ("+SG_Typ+")";1567 ring RingB=CharOfRing,x,ds;1568 // Morse(@f, Kbestimmt(@f));1569 return(string(x^(Mu+1)), @tp); 1570 } 1571 /////////////////////////////////////////////////////////////////////////////// 1572 proc Funktion4 1522 string s = "The singularity `"+string(Show(f)); 1523 string tp = "A["+string(Mu)+"]"; 1524 1525 s = s +"' is Requivalent to "+tp+"."; 1526 s; // +" ("+SG_Typ+")"; 1527 ring RingB=char(basering),x,ds; 1528 // Morse(f, Kbestimmt(f)); 1529 return(string(x^(Mu+1)), tp); 1530 } 1531 1532 /////////////////////////////////////////////////////////////////////////////// 1533 proc Funktion4 (poly f, int corank) 1573 1534 USAGE: 1574 1535 { 1575 poly @f = #[1]; 1576 string @s = "The singularity `"+Show(jet(@f, K)); 1577 string @tp = "D[4]"; 1578 1579 @s = @s +"' is Requivalent to "+@tp+"."; 1580 @s; // +" ("+SG_Typ+")"; 1581 return(Show(@f), @tp); 1582 } 1583 /////////////////////////////////////////////////////////////////////////////// 1584 proc Funktion5 1536 string s = "The singularity `"+Show(jet(f, K)); 1537 string tp = "D[4]"; 1538 1539 s = s +"' is Requivalent to "+tp+"."; 1540 s; // +" ("+SG_Typ+")"; 1541 setring @Rtop; 1542 return(Show(f), tp); 1543 // return(f, tp); 1544 } 1545 1546 /////////////////////////////////////////////////////////////////////////////// 1547 proc Funktion5 (poly f, int corank) 1585 1548 USAGE: 1586 1549 { 1587 poly @f = #[1];1588 string @s = "The singularity `"+Show(jet(@f, K));1589 string @tp = "D["+string(Mu)+"]"; 1590 1591 @s = @s +"' is Requivalent to "+@tp+".";1592 @s; // +" ("+SG_Typ+")";1593 return(Show(@f), @tp); 1594 } 1550 string s = "The singularity `"+Show(jet(f, K)); 1551 string tp = "D["+string(Mu)+"]"; 1552 1553 s = s +"' is Requivalent to "+tp+"."; 1554 s; // +" ("+SG_Typ+")"; 1555 return(Show(f), tp); 1556 } 1557 1595 1558 /////////////////////////////////////////////////////////////////////////////// 1596 1559 proc Funktion7 … … 1607 1570 return(Show(@f), @tp); 1608 1571 } 1572 1609 1573 /////////////////////////////////////////////////////////////////////////////// 1610 1574 proc Funktion8 … … 1621 1585 return(Show(@f), @tp); 1622 1586 } 1587 1623 1588 /////////////////////////////////////////////////////////////////////////////// 1624 1589 proc Funktion9 … … 1635 1600 return(Show(@f), @tp); 1636 1601 } 1602 1637 1603 /////////////////////////////////////////////////////////////////////////////// 1638 1604 proc Funktion11 … … 1649 1615 return(Show(@f), @tp); 1650 1616 } 1617 1651 1618 /////////////////////////////////////////////////////////////////////////////// 1652 1619 proc Funktion12 … … 1664 1631 return(Show(@f), @tp); 1665 1632 } 1633 1666 1634 /////////////////////////////////////////////////////////////////////////////// 1667 1635 proc Funktion14 … … 1677 1645 return(Show(@f), @tp); 1678 1646 } 1647 1679 1648 /////////////////////////////////////////////////////////////////////////////// 1680 1649 proc Funktion15 … … 1691 1660 return(Show(@f), @tp); 1692 1661 } 1662 1693 1663 /////////////////////////////////////////////////////////////////////////////// 1694 1664 proc Funktion16 … … 1707 1677 return(Show(@f), @tp); 1708 1678 } 1679 1709 1680 /////////////////////////////////////////////////////////////////////////////// 1710 1681 proc Funktion19 … … 1720 1691 return(Show(@f), @tp); 1721 1692 } 1693 1722 1694 /////////////////////////////////////////////////////////////////////////////// 1723 1695 proc Funktion20 … … 1733 1705 return(Show(@f), @tp); 1734 1706 } 1707 1735 1708 /////////////////////////////////////////////////////////////////////////////// 1736 1709 proc Funktion21 … … 1746 1719 return(Show(@f), @tp); 1747 1720 } 1721 1748 1722 /////////////////////////////////////////////////////////////////////////////// 1749 1723 proc Funktion23 … … 1759 1733 return(Show(@f), @tp); 1760 1734 } 1735 1761 1736 /////////////////////////////////////////////////////////////////////////////// 1762 1737 proc Funktion24 … … 1773 1748 return(Show(@f), @tp); 1774 1749 } 1750 1775 1751 /////////////////////////////////////////////////////////////////////////////// 1776 1752 proc Funktion27 … … 1786 1762 return(Show(@f), @tp); 1787 1763 } 1764 1788 1765 /////////////////////////////////////////////////////////////////////////////// 1789 1766 proc Funktion28 … … 1799 1776 return(Show(@f), @tp); 1800 1777 } 1778 1801 1779 /////////////////////////////////////////////////////////////////////////////// 1802 1780 proc Funktion30 … … 1812 1790 return(Show(@f), @tp); 1813 1791 } 1792 1814 1793 /////////////////////////////////////////////////////////////////////////////// 1815 1794 proc Funktion31 … … 1826 1805 return(Show(@f), @tp); 1827 1806 } 1807 1828 1808 /////////////////////////////////////////////////////////////////////////////// 1829 1809 proc Funktion32 … … 1840 1820 return(Show(@f), @tp); 1841 1821 } 1822 1842 1823 /////////////////////////////////////////////////////////////////////////////// 1843 1824 proc Funktion34 … … 1853 1834 return(Show(@f), @tp); 1854 1835 } 1836 1855 1837 /////////////////////////////////////////////////////////////////////////////// 1856 1838 proc Funktion35 … … 1866 1848 return(Show(@f), @tp); 1867 1849 } 1850 1868 1851 /////////////////////////////////////////////////////////////////////////////// 1869 1852 proc Funktion37 … … 1879 1862 return(Show(@f), @tp); 1880 1863 } 1864 1881 1865 /////////////////////////////////////////////////////////////////////////////// 1882 1866 proc Funktion38 … … 1893 1877 return(Show(@f), @tp); 1894 1878 } 1879 1895 1880 /////////////////////////////////////////////////////////////////////////////// 1896 1881 proc Funktion39 … … 1906 1891 return(Show(@f), @tp); 1907 1892 } 1893 1908 1894 /////////////////////////////////////////////////////////////////////////////// 1909 1895 proc Funktion42 … … 1920 1906 return(Show(@f), @tp); 1921 1907 } 1908 1922 1909 /////////////////////////////////////////////////////////////////////////////// 1923 1910 proc Funktion43 … … 1934 1921 return(Show(@f), @tp); 1935 1922 } 1923 1936 1924 /////////////////////////////////////////////////////////////////////////////// 1937 1925 proc Funktion44 … … 1948 1936 return(Show(@f), @tp); 1949 1937 } 1938 1950 1939 /////////////////////////////////////////////////////////////////////////////// 1951 1940 proc Funktion45 … … 1963 1952 return(Show(@f), @tp); 1964 1953 } 1954 1965 1955 /////////////////////////////////////////////////////////////////////////////// 1966 1956 proc Funktion47 … … 1979 1969 return(Show(@f), @tp); 1980 1970 } 1971 1981 1972 /////////////////////////////////////////////////////////////////////////////// 1982 1973 proc Funktion60 … … 1992 1983 return(Show(@f), @tp); 1993 1984 } 1985 1994 1986 /////////////////////////////////////////////////////////////////////////////// 1995 1987 proc Funktion61 … … 2005 1997 return(Show(@f), @tp); 2006 1998 } 1999 2007 2000 /////////////////////////////////////////////////////////////////////////////// 2008 2001 proc Funktion62 … … 2018 2011 return(Show(@f), @tp); 2019 2012 } 2013 2020 2014 /////////////////////////////////////////////////////////////////////////////// 2021 2015 proc Funktion64 … … 2031 2025 return(Show(@f), @tp); 2032 2026 } 2027 2033 2028 /////////////////////////////////////////////////////////////////////////////// 2034 2029 proc Funktion65 … … 2045 2040 return(Show(@f), @tp); 2046 2041 } 2042 2047 2043 /////////////////////////////////////////////////////////////////////////////// 2048 2044 proc Funktion84 … … 2055 2051 return(FunktionNoClass(#[1])); 2056 2052 } 2053 2057 2054 /////////////////////////////////////////////////////////////////////////////// 2058 2055 proc Funktion86 … … 2065 2062 return(FunktionNoClass(#[1])); 2066 2063 } 2064 2067 2065 /////////////////////////////////////////////////////////////////////////////// 2068 2066 proc Funktion87 … … 2075 2073 return(FunktionNoClass(#[1])); 2076 2074 } 2075 2077 2076 /////////////////////////////////////////////////////////////////////////////// 2078 2077 proc Funktion89 … … 2085 2084 return(FunktionNoClass(#[1])); 2086 2085 } 2086 2087 2087 /////////////////////////////////////////////////////////////////////////////// 2088 2088 proc Funktion100 … … 2099 2099 return(Show(@f), @tp); 2100 2100 } 2101 2101 2102 /////////////////////////////////////////////////////////////////////////////// 2102 2103 proc Funktion101 … … 2113 2114 return(Show(@f), @tp); 2114 2115 } 2116 2117 /////////////////////////////////////////////////////////////////////////////// 2118 2115 2119 /////////////////////////////////////////////////////////////////////////////// 2116 2120 proc internalfunctions … … 2212 2216 //proc internalfunctions 2213 2217 //proc tschirnhaus (poly @f, poly @x) 2218 /////////////////////////////////////////////////////////////////////////////// 2219 // initialisation  2220 // output 
Note: See TracChangeset
for help on using the changeset viewer.