1 | // $Id: classify.lib,v 1.11 1997-08-15 07:34:55 krueger Exp $ |
---|
2 | //============================================================================= |
---|
3 | // |
---|
4 | // Please send bugs and comments to krueger@mathematik.uni-kl.de |
---|
5 | // |
---|
6 | //============================================================================= |
---|
7 | |
---|
8 | LIBRARY: Classify.lib |
---|
9 | |
---|
10 | classify(f); compute the Class of f. |
---|
11 | |
---|
12 | LIBRARY: Kclass.lib |
---|
13 | Klassifiziere(poly f); determine the typ of the singularity f |
---|
14 | Funktion1bis(poly f, int corank); (for internal use only) |
---|
15 | Funktion3(poly f, int corank); (for internal use only) |
---|
16 | Funktion6(poly f, int corank); (for internal use only) |
---|
17 | Funktion13(poly f, int corank); (for internal use only) |
---|
18 | Funktion17(poly f, int corank); (for internal use only) |
---|
19 | Funktion25(poly f, int corank); (for internal use only) |
---|
20 | Funktion40(poly f, int corank); (for internal use only) |
---|
21 | Funktion50(poly f, int corank); (for internal use only) |
---|
22 | Funktion51(poly f, int corank); (for internal use only) |
---|
23 | Funktion52(poly f, int corank); (for internal use only) |
---|
24 | Funktion54(poly f, int corank); (for internal use only) |
---|
25 | Funktion56(poly f, int corank); (for internal use only) |
---|
26 | Funktion58(poly f, int corank); (for internal use only) |
---|
27 | Funktion59(poly f, int corank); (for internal use only) |
---|
28 | Funktion66(poly f, int corank); (for internal use only) |
---|
29 | Funktion82(poly f, int corank); (for internal use only) |
---|
30 | Funktion83(poly f, int corank); (for internal use only) |
---|
31 | Funktion97(poly f, int corank); (for internal use only) |
---|
32 | Funktion103(poly f, int corank); (for internal use only) |
---|
33 | Funktion104(poly f, int corank); (for internal use only) |
---|
34 | Funktion105(poly f, int corank); (for internal use only) |
---|
35 | FunktionNoClass(poly f, int corank); (for internal use only) |
---|
36 | Isomorphie_s82_x(poly f, poly fk, int k); (for internal use only) |
---|
37 | Isomorphie_s82_z(poly f, poly fk, int k); (for internal use only) |
---|
38 | Tschirnhaus(poly f, int corank); (for internal use only) |
---|
39 | Isomorphie_s17 (poly f, poly fk, int k, int ct); |
---|
40 | |
---|
41 | // required libraries |
---|
42 | |
---|
43 | LIB "Morse.lib"; |
---|
44 | LIB "tools.lib"; |
---|
45 | LIB "NFlist.lib"; |
---|
46 | LIB "Hilbert.lib"; |
---|
47 | |
---|
48 | //============================================================================= |
---|
49 | //============================================================================= |
---|
50 | // TopLevel Funktion of the Arnold-Classifier. |
---|
51 | // |
---|
52 | proc classify (poly @f_in) |
---|
53 | USAGE: classify(f); f=poly |
---|
54 | COMPUTE: Normalform and singularity type of f |
---|
55 | RETURN: Normalform of f |
---|
56 | EXAMPLE: example classify; shows an example |
---|
57 | REMARK: This version of classify is only alpha. |
---|
58 | Please send bugs and comments to: |
---|
59 | "Kai Krueger" <krueger@mathematik.uni-kl.de> |
---|
60 | NOTE: The procedure init_debug(n); is usefull as trace-mode. |
---|
61 | n may range from 0 to 10, higher values of n give more information. |
---|
62 | { |
---|
63 | // or set the shell-variable SG_DEBUG to the debugging level. |
---|
64 | if(system("version")<922) { |
---|
65 | "Sorry. You need to have at least Singular version 0.9.2.c" |
---|
66 | return; |
---|
67 | } |
---|
68 | |
---|
69 | def ring_top=basering; |
---|
70 | // Get characteristics of ring set it as default. |
---|
71 | if(defined(CharOfRing) == 1) { kill CharOfRing; } |
---|
72 | int CharOfRing = char(basering); |
---|
73 | export CharOfRing; |
---|
74 | |
---|
75 | if(checkring()) { return(@f_in); } |
---|
76 | int @show_nf = 1; // return normal form if set to '1' |
---|
77 | |
---|
78 | int @n = nvars(basering); |
---|
79 | |
---|
80 | // Save the name of initial ring |
---|
81 | int @i; |
---|
82 | |
---|
83 | // if trace/debug mode not set, do it! |
---|
84 | init_debug(); |
---|
85 | |
---|
86 | // define new ring |
---|
87 | if( defined(Rtop) == 1) { kill Rtop; } |
---|
88 | ring Rtop=char(basering),(x(1..@n)),(c,ds); |
---|
89 | export Rtop; |
---|
90 | |
---|
91 | map @Conv=ring_top,maxideal(1); |
---|
92 | setring ring_top; |
---|
93 | |
---|
94 | if(defined(ShowPoly) == 1) { kill ShowPoly; } |
---|
95 | map ShowPoly=Rtop,maxideal(1); |
---|
96 | export ShowPoly; |
---|
97 | setring Rtop; |
---|
98 | init(); |
---|
99 | |
---|
100 | string RingDisplay = "ring_top"; |
---|
101 | export RingDisplay; |
---|
102 | |
---|
103 | string @s1; |
---|
104 | string @s2; |
---|
105 | string @s4; |
---|
106 | @s1,@s2=Klassifiziere(@Conv(@f_in)); |
---|
107 | // @s1: f nach saemtlichen Koordinatentransformationen |
---|
108 | // @s2: Typ des Polynoms f z.b: E[18] |
---|
109 | @s4 = "poly @f_out="+@s1+";"; |
---|
110 | debug_log(10, "S1=", @s1); |
---|
111 | debug_log(10, "S2=", @s2); |
---|
112 | |
---|
113 | if( @s2[1,2]=="f " || @s2[1,4]=="The " || @s2=="Fehler!" || @s2=="A[0]") { |
---|
114 | if( @s2 != "Fehler!") { @s2; } |
---|
115 | if(@s1=="1" || @s2[1,4]=="The " || @s2=="Fehler!" ) { |
---|
116 | setring ring_top; |
---|
117 | return(@f_in); |
---|
118 | } |
---|
119 | setring Rtop; |
---|
120 | execute @s4; |
---|
121 | map @ConvUp=Rtop,maxideal(1); |
---|
122 | } |
---|
123 | else { |
---|
124 | setring RingB; |
---|
125 | execute @s4; |
---|
126 | setring Rtop; |
---|
127 | map @ConvUp=RingB,maxideal(1); |
---|
128 | } |
---|
129 | if(@show_nf==1) { |
---|
130 | poly @f_nf = normalform(@s2); |
---|
131 | for(@i=4;@i<=@n;@i=@i+1) { |
---|
132 | @f_nf = @f_nf + x(@i)^2; |
---|
133 | } |
---|
134 | if(DeBug>1) { "Normal form NF(f)=", @f_nf; } |
---|
135 | } |
---|
136 | poly @f_out = @ConvUp(@f_out); |
---|
137 | for(@i=CoRang+1;@i<=@n;@i=@i+1) { |
---|
138 | @f_out = @f_out + x(@i)^2; |
---|
139 | } |
---|
140 | setring ring_top; |
---|
141 | map @ConvBack=Rtop,maxideal(1); |
---|
142 | |
---|
143 | if(@show_nf == 1) { |
---|
144 | return(@ConvBack(@f_nf)); |
---|
145 | } |
---|
146 | else { return(@ConvBack(@f_out)); } |
---|
147 | } |
---|
148 | example |
---|
149 | {"EXAMPLE"; echo=2; |
---|
150 | ring r=0,(x,y,z),ds; |
---|
151 | init_debug(2); |
---|
152 | poly f=(x2+3y-2z)^2+xyz-(x-y3+x2*z3)^3; |
---|
153 | poly g=classify(f); |
---|
154 | } |
---|
155 | //============================================================================= |
---|
156 | // Id: Kclass.lib,v 1.12 1997/08/13 17:21:05 krueger Exp |
---|
157 | /============================================================================= |
---|
158 | // |
---|
159 | // Please send bugs and comments to krueger@mathematik.uni-kl.de |
---|
160 | // |
---|
161 | //============================================================================= |
---|
162 | |
---|
163 | //========================================================================= |
---|
164 | proc Kclass_lib |
---|
165 | { |
---|
166 | " |
---|
167 | Klassifiziere(poly f); determine the typ of the singularity f |
---|
168 | Funktion1bis(poly f, int corank); (for internal use only) |
---|
169 | Funktion3(poly f, int corank); (for internal use only) |
---|
170 | Funktion6(poly f, int corank); (for internal use only) |
---|
171 | Funktion13(poly f, int corank); (for internal use only) |
---|
172 | Funktion17(poly f, int corank); (for internal use only) |
---|
173 | Funktion25(poly f, int corank); (for internal use only) |
---|
174 | Funktion40(poly f, int corank); (for internal use only) |
---|
175 | Funktion50(poly f, int corank); (for internal use only) |
---|
176 | Funktion51(poly f, int corank); (for internal use only) |
---|
177 | Funktion52(poly f, int corank); (for internal use only) |
---|
178 | Funktion54(poly f, int corank); (for internal use only) |
---|
179 | Funktion56(poly f, int corank); (for internal use only) |
---|
180 | Funktion58(poly f, int corank); (for internal use only) |
---|
181 | Funktion59(poly f, int corank); (for internal use only) |
---|
182 | Funktion66(poly f, int corank); (for internal use only) |
---|
183 | Funktion82(poly f, int corank); (for internal use only) |
---|
184 | Funktion83(poly f, int corank); (for internal use only) |
---|
185 | Funktion97(poly f, int corank); (for internal use only) |
---|
186 | Funktion103(poly f, int corank); (for internal use only) |
---|
187 | Funktion104(poly f, int corank); (for internal use only) |
---|
188 | Funktion105(poly f, int corank); (for internal use only) |
---|
189 | FunktionNoClass(poly f, int corank); (for internal use only) |
---|
190 | Isomorphie_s82_x(poly f, poly fk, int k); (for internal use only) |
---|
191 | Isomorphie_s82_z(poly f, poly fk, int k); (for internal use only) |
---|
192 | Tschirnhaus(poly f, int corank); (for internal use only) |
---|
193 | "; |
---|
194 | } |
---|
195 | |
---|
196 | //============================================================================= |
---|
197 | proc Klassifiziere (poly @f) |
---|
198 | USAGE: Klassifiziere(f); |
---|
199 | { |
---|
200 | string @s1; |
---|
201 | int @cnt; |
---|
202 | // Warum hier init() noch einmal, keine Ahnung. |
---|
203 | // Wenn nicht geht's einfach nicht. Hans fragen! |
---|
204 | init(1); |
---|
205 | int @n = nvars(basering); // Zahl der Variablen des aktuellen Rings. |
---|
206 | |
---|
207 | // Define always 'RingDisplay' to be able to run 'Show(f)' |
---|
208 | if( defined(RingDisplay) == 0) { |
---|
209 | string RingDisplay; |
---|
210 | export RingDisplay; |
---|
211 | } |
---|
212 | RingDisplay = "setring RingB;"; |
---|
213 | |
---|
214 | if(defined(SG_Typ) == 1) { kill SG_Typ; } // Typ(s) von f nach Hilbert. |
---|
215 | string SG_Typ = ""; |
---|
216 | export SG_Typ; |
---|
217 | |
---|
218 | // |
---|
219 | @s1 = "ring RingB="+string(CharOfRing)+",("+A_Z("x", @n)+"),ds;"; |
---|
220 | execute @s1; // in diesem Ring werden Polynome angezeigt. |
---|
221 | @s1 = "map ShowPoly=Rtop,"+A_Z("x", @n)+";"; |
---|
222 | execute @s1; // Hiermit werden Polynome angezeigt. |
---|
223 | export ShowPoly; |
---|
224 | setring Rtop; // in den Ausgangs-ring zurueck. |
---|
225 | export RingB; |
---|
226 | |
---|
227 | //=============================================== |
---|
228 | |
---|
229 | if(jet(@f,0) != 0 ) { |
---|
230 | if(defined(CoRang) == 0) { int CoRang = CoRangf(@f); } |
---|
231 | return("1", "f is a unit"); |
---|
232 | } |
---|
233 | |
---|
234 | debug_log(1, "Computing Basicinvariants of f ..."); |
---|
235 | if(defined(Mu) == 1) { kill Mu; } |
---|
236 | if(defined(K) == 1) { kill K; } |
---|
237 | if(defined(CoRang) == 1) { kill CoRang; } |
---|
238 | int K; |
---|
239 | int Mu; |
---|
240 | int CoRang; |
---|
241 | K, Mu, CoRang = basicinvariants(@f); |
---|
242 | "About the singularity :"; |
---|
243 | " Milnor number(f) = "+string(Mu); |
---|
244 | " Corank(f) = "+string(CoRang); |
---|
245 | " Determinacy <= "+string(K); |
---|
246 | export CoRang, K, Mu; |
---|
247 | |
---|
248 | // ideal @Jf = Jf; |
---|
249 | // if(dim(std(EH(@Jf))) != @n) { return("x(1)","A[0]"); } |
---|
250 | if( Mu == 0) { |
---|
251 | CoRang=1; |
---|
252 | return("x(1)","A[0]"); |
---|
253 | } |
---|
254 | |
---|
255 | if(Mu<0) { |
---|
256 | "The Milnor number of the function is infinite."; |
---|
257 | "The singularity is not in Arnolds list."; |
---|
258 | return("", "Fehler!"); |
---|
259 | } |
---|
260 | |
---|
261 | @f = jet(@f, K); |
---|
262 | @s1,@cnt = HKclass(Hilb(@f)); |
---|
263 | if(@cnt>0) { "Guessing type via Hilbert polynomial: ", @s1; } |
---|
264 | else { "Hilbert polynomial not recognised. Milnor code = ", Hilb(@f); } |
---|
265 | ""; |
---|
266 | "Computing normal form ..."; |
---|
267 | |
---|
268 | // Einteilung nach Corang |
---|
269 | if( defined(ShowPhi) == 0) { int ShowPhi = 0; } |
---|
270 | if(CoRang == 0) { return(Funktion2(@f, CoRang)); } |
---|
271 | if(CoRang == 1) { return(Funktion2(@f, CoRang)); } |
---|
272 | if(CoRang == 2) { return(Funktion1bis(@f, CoRang)); } |
---|
273 | if(CoRang == 3) { return(Funktion1bis(@f, CoRang)); } |
---|
274 | return(Funktion105(@f, CoRang)); |
---|
275 | } |
---|
276 | //============================================================================= |
---|
277 | proc Funktion1bis (poly @f, int corank) |
---|
278 | USAGE: Funktion1bis(); |
---|
279 | { // pruefe ob abspaltung von Quadraten noetig, wenn ja tue dies. |
---|
280 | |
---|
281 | int @n = nvars(basering); |
---|
282 | string @s1; |
---|
283 | string @RestRing = nameof(basering); |
---|
284 | |
---|
285 | if( @n > corank) { |
---|
286 | "I have to apply the splitting lemma. This will take some time....:-)"; |
---|
287 | poly @g = Morse(@f, K, corank); |
---|
288 | |
---|
289 | @g = ReOrder(@g); |
---|
290 | if(defined(PhiG)==1) { kill PhiG; } |
---|
291 | if(defined(Rrest) == 1) { kill Rrest; } |
---|
292 | if(defined(ShowPoly) == 1 ) { kill ShowPoly; } |
---|
293 | if(defined(RingB) == 1) { kill RingB; } |
---|
294 | |
---|
295 | execute Setring(corank, "Rrest"); |
---|
296 | export Rrest; |
---|
297 | @RestRing = nameof(basering); |
---|
298 | |
---|
299 | map @MapReduce=Rtop,maxideal(1); |
---|
300 | poly @G = @MapReduce(@g); |
---|
301 | |
---|
302 | @s1 = "map PhiG=Rtop," + string(maxideal(1));// Konstruiere Id auf r |
---|
303 | execute @s1; |
---|
304 | export PhiG; |
---|
305 | |
---|
306 | @s1 = "ring RingB=",string(CharOfRing),",("+A_Z("x", corank)+"),ds;"; |
---|
307 | execute @s1; |
---|
308 | export RingB; |
---|
309 | } |
---|
310 | else { poly @G = @f; } |
---|
311 | |
---|
312 | setring RingB; |
---|
313 | @s1 = "map ShowPoly=",@RestRing,","+A_Z("x", corank)+";"; |
---|
314 | execute @s1; |
---|
315 | export ShowPoly; |
---|
316 | @s1 = "setring ",@RestRing,";"; |
---|
317 | execute @s1; |
---|
318 | |
---|
319 | if(defined(PhiG)==0) { |
---|
320 | map PhiG=basering, maxideal(1); |
---|
321 | export PhiG; |
---|
322 | } |
---|
323 | if(corank == 2) { return(Funktion3(@G, corank)); } |
---|
324 | if(corank == 3) { return(Funktion50(@G, corank)); } |
---|
325 | return("","Fehler!"); |
---|
326 | } |
---|
327 | //============================================================================= |
---|
328 | proc Funktion3 (poly @f, int corank); |
---|
329 | USAGE: Funktion3(); |
---|
330 | { |
---|
331 | poly @f3 = jet(@f, 3); |
---|
332 | debug_log(1, "Schritt 3"); |
---|
333 | |
---|
334 | if( @f3 == 0 ) { return(Funktion13(@f, corank)); } |
---|
335 | |
---|
336 | // f3 ~ x3 , x2y+y3 , x2y |
---|
337 | ideal @Jf = jacob(@f3); |
---|
338 | @Jf = std(@Jf); |
---|
339 | int @Dim = dim(@Jf); |
---|
340 | if(@Dim == 0) { return(Funktion4(@f, corank)); } // D[4] |
---|
341 | |
---|
342 | if(@Dim == 1) { |
---|
343 | if( mult(@Jf) == 1) { return(Funktion5(@f, corank)); } // D[k] |
---|
344 | if( mult(@Jf) == 2) { return(Funktion6(@f, corank)); } // E[k], J |
---|
345 | "dimension 1 und deg != 1, 2 => error, this should never occur"; |
---|
346 | return("", "Fehler!"); // Should never occur |
---|
347 | } |
---|
348 | return("", "Fehler!"); // Should never occur |
---|
349 | } |
---|
350 | //============================================================================= |
---|
351 | //proc Funktion6 - put here |
---|
352 | proc Funktion6 (poly @f, int corank) |
---|
353 | USAGE: Funktion6() |
---|
354 | { |
---|
355 | int @n = nvars(basering); // Zahl der Ringvariablen |
---|
356 | poly @f3 = jet(@f, 3); // 3-Jet von f |
---|
357 | poly @fk; // k-Jet von f mit Gewichten |
---|
358 | ideal @JetId; // Ideal fuer Gewichteten Jet |
---|
359 | ideal @Jf; // jacob(@fk) |
---|
360 | int @Dim; // dim(@Jf) |
---|
361 | int @Mult; // mult(@Jf) |
---|
362 | int @k = 1; // |
---|
363 | |
---|
364 | debug_log(1, " Schritt 6"); |
---|
365 | |
---|
366 | GetRf(@f, @n); |
---|
367 | @f = Faktorisiere(@f, @f3, 3, 1); |
---|
368 | |
---|
369 | |
---|
370 | //------------------------------------------------------- |
---|
371 | // Bestimme nun Typ der E[k] |
---|
372 | while( (6*@k) <= Mu ) { |
---|
373 | @JetId = x(1)^3+x(2)^(3*@k); |
---|
374 | @fk = jet(@f, 3*@k, weight(@JetId)); |
---|
375 | if( @fk == Coeff(@fk,x(1), x(1)^3)*x(1)^3 ) { |
---|
376 | //------------------------------------------------------- |
---|
377 | // Pruefe Jet x3,y3k+1 : E[6k] |
---|
378 | @JetId = x(1)^3+x(2)^(3*@k+1); |
---|
379 | @fk = jet(@f, 3*(3*@k+1), weight(@JetId)); |
---|
380 | if( Coeff(@fk,x(2),x(2)^(3*@k+1)) != 0 ) { return(Funktion7(@f,@k)); } |
---|
381 | |
---|
382 | //------------------------------------------------------- |
---|
383 | // Pruefe Jet x3,xy2k+1 : E[6k+1] |
---|
384 | @JetId = x(1)^3+x(1)*x(2)^(2*@k+1); |
---|
385 | @fk = jet(@f, 3*(2*@k+1), weight(@JetId)); |
---|
386 | if( Coeff(@fk, x(1)*x(2), x(1)*x(2)^(2*@k+1)) != 0 ) { |
---|
387 | return(Funktion8(@f,@k)); } |
---|
388 | |
---|
389 | //------------------------------------------------------- |
---|
390 | // Pruefe Jet x3,y3k+1 : E[6k+2] |
---|
391 | @JetId = x(1)^3+x(2)^(3*@k+2); |
---|
392 | @fk = jet(@f, 3*(3*@k+2), weight(@JetId)); |
---|
393 | if( Coeff(@fk,x(2),x(2)^(3*@k+2)) != 0 ) { return(Funktion9(@f,@k)); } |
---|
394 | |
---|
395 | //------------------------------------------------------- |
---|
396 | // Arnold - Funktion 10 mit k+1 |
---|
397 | // Gehe zu Funktion 10 mit k+1 |
---|
398 | @k=@k+1; |
---|
399 | @JetId = x(1)^3+x(2)^(3*@k); |
---|
400 | @fk = jet(@f, 3*@k, weight(@JetId)); |
---|
401 | @Jf = std(jacob(@fk)); |
---|
402 | @Dim = dim(@Jf); |
---|
403 | //------------------------------------------------- |
---|
404 | // Pruefe : fk ~ x3 + ax2yk + y3k mit 4a3+27 <> 0 |
---|
405 | if( @Dim == 0 ) { return(Funktion11(@f,@k)); } |
---|
406 | |
---|
407 | //------------------------------------------------- |
---|
408 | // Pruefe : fk ~ x3 + x2yk |
---|
409 | @Mult = mult(@Jf); |
---|
410 | if( @Dim ==1 && @Mult==1) { return(Funktion12(@f,@k)); } |
---|
411 | //------------------------------------------------- |
---|
412 | // Pruefe : fk ~ x3 |
---|
413 | if( @Dim == 1 && @Mult == 2) { |
---|
414 | if(Coeff(@fk, x(2), x(2)^(3*@k)) != 0) { |
---|
415 | @f = Faktorisiere(@f, @fk, 3, @k); |
---|
416 | } |
---|
417 | } |
---|
418 | } |
---|
419 | } |
---|
420 | return("","Fehler!"); |
---|
421 | } |
---|
422 | //============================================================================= |
---|
423 | //proc Funktion13 - put here |
---|
424 | //========================================================================= |
---|
425 | // Id: lib_WorkOn,v 1.8 1995/01/27 12:53:11 krueger Exp |
---|
426 | // |
---|
427 | //============================================================================= |
---|
428 | // |
---|
429 | |
---|
430 | //========================================================================= |
---|
431 | proc Funktion13 (poly @f, int corank) |
---|
432 | USAGE: Funktion13(); |
---|
433 | { |
---|
434 | poly @f4 = jet(@f, 4); |
---|
435 | debug_log(1, " Schritt 13"); |
---|
436 | if( @f4 == 0 ) { return(Funktion47(@f, corank)); } |
---|
437 | |
---|
438 | // f4 ~ x4+ax2y2+y4, x4+x2y2, x2y2, x3y, x4 |
---|
439 | ideal @Jf = std(jacob(@f4)); |
---|
440 | int @Dim = dim(@Jf); |
---|
441 | int @Mult = mult(@Jf); |
---|
442 | |
---|
443 | if( @Dim == 0) { return(Funktion14(@f, corank)); } // X[9]=X[1,0]=T[2,4,4] |
---|
444 | if( @Dim == 1) { |
---|
445 | if( @Mult == 1 ) { return(Funktion15(@f, corank)); } |
---|
446 | if( @Mult == 2 ) { |
---|
447 | @Jf = @Jf, jacob(@Jf); |
---|
448 | @Jf = std(@Jf); |
---|
449 | @Dim = dim(@Jf); |
---|
450 | if( @Dim == 0 ) { return(Funktion16(@f, corank)); } |
---|
451 | if( @Dim == 1 ) { return(Funktion17(@f, corank)); } |
---|
452 | } |
---|
453 | if( @Mult == 3 ) { return(Funktion25(@f, corank)); } |
---|
454 | } |
---|
455 | return("","Fehler!"); |
---|
456 | } |
---|
457 | //============================================================================= |
---|
458 | //============================================================================= |
---|
459 | proc Funktion17 (poly @f, int corank) |
---|
460 | USAGE: Funktion17(); |
---|
461 | { // Analog zu Fumktion 6 |
---|
462 | // Komb. 17-24 |
---|
463 | int @p = 1; |
---|
464 | poly @fk = jet(@f, 4); |
---|
465 | poly @ft; |
---|
466 | ideal @JetId; |
---|
467 | ideal @Jf; |
---|
468 | int @Dim; |
---|
469 | int @Mult; |
---|
470 | |
---|
471 | debug_log(1, " Schritt 17"); |
---|
472 | while( 3*@p<= Mu) { |
---|
473 | debug_log(1, "Schritt 18(", @p, ")"); |
---|
474 | @f = Isomorphie_s17(@f, @fk, @p, 1); |
---|
475 | if ( @p>1) { |
---|
476 | @JetId = x(1)^3*x(2) + x(2)^(3*@p); // weight(@JetId); |
---|
477 | @fk = jet(@f, 3*@p, weight(@JetId)); |
---|
478 | } |
---|
479 | // Z[6p+5] |
---|
480 | @JetId = x(1)^3*x(2) + x(2)^(3*@p+2); |
---|
481 | @fk = jet(@f, 3*(3*@p+2), weight(@JetId)); |
---|
482 | if( Coeff(@fk, x(2), x(2)^(3*@p+2)) != 0) { return(Funktion19(@f, @p));} |
---|
483 | |
---|
484 | // Z[6p+6] |
---|
485 | @JetId = x(1)^3*x(2) + x(1)*x(2)^(2*@p+2); |
---|
486 | @fk = jet(@f, 2*(3*@p+2)+1, weight(@JetId)); |
---|
487 | if( Coeff(@fk, x(1)*x(2), x(1)*x(2)^(2*@p+2)) != 0) { |
---|
488 | return(Funktion20(@f, @p));} |
---|
489 | |
---|
490 | // Z[6p+7] |
---|
491 | @JetId = x(1)^3*x(2) + x(2)^(3*@p+3); |
---|
492 | @fk = jet(@f, 3*(3*@p+3), weight(@JetId)); |
---|
493 | if( Coeff(@fk, x(2), x(2)^(3*@p+3)) != 0) { return(Funktion21(@f, @p));} |
---|
494 | |
---|
495 | @p = @p+1; |
---|
496 | @JetId = x(1)^3*x(2) + x(2)^(3*@p+1); // weight(@JetId); |
---|
497 | @fk = jet(@f, 3*@p+1, weight(@JetId)); |
---|
498 | @ft = Teile(@fk, x(2)); |
---|
499 | @Jf = std(jacob(@ft)); |
---|
500 | @Dim = dim(@Jf); |
---|
501 | @Mult = mult(@Jf); |
---|
502 | // "fk=",Show(@fk)," ft=",Show(@ft)," p=",@p," Dim=", @Dim, " Mult=",@Mult; |
---|
503 | if( @Dim == 0 ) { return(Funktion23(@f, @p)); } |
---|
504 | if( @Mult == 1 ) { return(Funktion24(@f, @p)); } |
---|
505 | } |
---|
506 | return("","Fehler!"); |
---|
507 | } |
---|
508 | //============================================================================= |
---|
509 | proc Funktion25 (poly @f, int CoRang) |
---|
510 | USAGE: Funktion25(); |
---|
511 | { |
---|
512 | // // Komb. 25-46 |
---|
513 | // definition der Variablen |
---|
514 | int @k = 1; |
---|
515 | poly @fk = jet(@f, 4); |
---|
516 | poly @ft; |
---|
517 | ideal @JetId; |
---|
518 | ideal @Jf; |
---|
519 | int @Dim; |
---|
520 | int @Mult; |
---|
521 | debug_log(1, " Schritt 25"); |
---|
522 | |
---|
523 | // Code |
---|
524 | while (@k<Mu) { |
---|
525 | @f = Faktorisiere(@f, @fk, 4 , @k); |
---|
526 | |
---|
527 | // W[12k] |
---|
528 | @JetId = x(1)^4 + x(2)^(4*@k+1); |
---|
529 | @fk = jet(@f, 4*(4*@k+1), weight(@JetId)); |
---|
530 | if( Coeff(@fk, x(2), x(2)^(4*@k+1)) != 0) { return(Funktion27(@f, @k));} |
---|
531 | |
---|
532 | // W[12k+1] |
---|
533 | @JetId = x(1)^4 + x(1)*x(2)^(3*@k+1); |
---|
534 | @fk = jet(@f, 4*(3*@k+1), weight(@JetId)); |
---|
535 | if( Coeff(@fk, x(1)*x(2), x(1)*x(2)^(3*@k+1)) != 0) { |
---|
536 | return(Funktion28(@f, @k));} |
---|
537 | |
---|
538 | // |
---|
539 | @JetId = x(1)^4 + x(2)^(4*@k+2); |
---|
540 | @fk = jet(@f, 2*(4*@k+2), weight(@JetId)); |
---|
541 | if( Coeff(@fk, x(2), x(2)^(4*@k+2)) != 0) { |
---|
542 | @Jf = std(jacob(@fk)); |
---|
543 | @Dim = dim(@Jf); |
---|
544 | @Mult = mult(@Jf); |
---|
545 | // "fk="+string(@fk)+" Dim="+string(@Dim)+" mult="+string(@Mult); |
---|
546 | if( @Dim == 0 ) { return(Funktion30(@f, @k)); } |
---|
547 | if( @Dim == 1 ) { return(Funktion32(@f, @k)); } |
---|
548 | return("","Fehler!"); |
---|
549 | } |
---|
550 | else { |
---|
551 | // x^4 oder x^2(x^2+x(2)^2k+1) |
---|
552 | @ft = Teile(@fk, x(1)^2); |
---|
553 | @Jf = std(jacob(@ft)); |
---|
554 | @Dim = dim(@Jf); |
---|
555 | @Mult = mult(@Jf); |
---|
556 | // "1-fk="+string(@fk)+" Dim="+string(@Dim)+" mult="+string(@Mult); |
---|
557 | if( @Dim == 0 ) { return(Funktion31(@f, @k)); } |
---|
558 | if( @Dim != 1 ) { return("Fehler!",""); } |
---|
559 | |
---|
560 | @JetId = x(1)^4 + x(1)*x(2)^(3*@k+2); |
---|
561 | @fk = jet(@f, 4*(3*@k+2), weight(@JetId)); |
---|
562 | if( Coeff(@fk, x(1)*x(2), x(1)*x(2)^(3*@k+2)) != 0) { |
---|
563 | return(Funktion34(@f, @k)); } |
---|
564 | |
---|
565 | @JetId = x(1)^4 + x(2)^(4*@k+3); |
---|
566 | @fk = jet(@f, 4*(4*@k+3), weight(@JetId)); |
---|
567 | if( Coeff(@fk, x(2), x(2)^(4*@k+3)) != 0) { return(Funktion35(@f, @k)); } |
---|
568 | |
---|
569 | @k = @k+1; |
---|
570 | @JetId = x(1)^4 + x(2)^(4*@k); |
---|
571 | @fk = jet(@f, (4*@k), weight(@JetId)); |
---|
572 | |
---|
573 | @Jf = std(jacob(@fk)); |
---|
574 | @Dim = dim(@Jf); |
---|
575 | @Mult = mult(@Jf); |
---|
576 | // "2-ft="+Show(@fk)+" Dim="+string(@Dim)+" mult="+string(@Mult); |
---|
577 | if( @Dim == 0 ) { return(Funktion37(@f, @k)); } |
---|
578 | if( @Dim == 1 ) { |
---|
579 | if( @Mult == 1 ) { return(Funktion38(@f, @k)); } |
---|
580 | if( @Mult == 2 ) { |
---|
581 | @ft = Teile(@fk, x(1)^2); |
---|
582 | @Jf = std(jacob(@ft)); |
---|
583 | @Dim = dim(@Jf); |
---|
584 | @Mult = mult(@Jf); |
---|
585 | // "3-ft="+Show(@ft)+" Dim="+string(@Dim)+" mult="+string(@Mult); |
---|
586 | if( @Dim == 0) { return(Funktion40(@f, @k)); } |
---|
587 | if( @Dim == 1) { return(Funktion39(@f, @k)); } |
---|
588 | } |
---|
589 | if( @Mult != 3 ) { return("","Fehler!"); } |
---|
590 | } |
---|
591 | else { return("","Fehler!"); } |
---|
592 | } |
---|
593 | } // Ende der While-Schleife |
---|
594 | return("","Fehler!"): |
---|
595 | } |
---|
596 | //============================================================================= |
---|
597 | proc Funktion40 (poly @f, int @k) |
---|
598 | USAGE: Funktion40(); |
---|
599 | { |
---|
600 | // poly @f = #[1]; |
---|
601 | // int @k = #[2]; |
---|
602 | int @r; |
---|
603 | string @Typ; |
---|
604 | string @fkt; |
---|
605 | string @RestRing; |
---|
606 | string @s1; |
---|
607 | int @kr; |
---|
608 | int @rr; |
---|
609 | int @sr; |
---|
610 | debug_log(1, " Schritt 40" ); |
---|
611 | string @s = "Die Singularitaet `"+Show(jet(@f, K-1)); |
---|
612 | @s = @s + "' ist vom Typ "; |
---|
613 | @s = @s + "Z["+string(@k)+",i,p](F40), mu="+string(Mu); |
---|
614 | @s = @s + ", m="+string(@k-1); |
---|
615 | @s; |
---|
616 | |
---|
617 | "------------------------ F 40 --------------"; |
---|
618 | poly @a; |
---|
619 | poly @b; |
---|
620 | poly @c; |
---|
621 | ideal @JetId = x(1)^4 + x(2)^(4*@k); |
---|
622 | poly @fk = jet(@f, (4*@k), weight(@JetId)); |
---|
623 | |
---|
624 | poly @f2 = -@fk / x(1)^3; |
---|
625 | ideal @Jfsyz = @f - @fk, x(1)^3, @f2; |
---|
626 | "f2=", @f2; |
---|
627 | "fk=", @fk; |
---|
628 | @Jfsyz; |
---|
629 | matrix @Mat = matrix(syz(@Jfsyz)); |
---|
630 | "Mat[1,1]="+Show(@Mat[1,1]); |
---|
631 | "Mat[1,2]="+Show(@Mat[1,2]); |
---|
632 | "Mat[2,1]="+Show(@Mat[2,1]); |
---|
633 | "Mat[2,2]="+Show(@Mat[2,2]); |
---|
634 | "Mat[3,1]="+Show(@Mat[3,1]); |
---|
635 | "Mat[3,2]="+Show(@Mat[3,2]); |
---|
636 | "---"; |
---|
637 | @a = @Mat[2,1] / @Mat[1,1] - @Mat[2,2]; |
---|
638 | @b = - @Mat[3,1] / @Mat[1,1] + @Mat[3,2]; |
---|
639 | "f1 = "+Show(@a); |
---|
640 | "f2 = "+Show(@b); |
---|
641 | "---"; |
---|
642 | "f1 * f2 = "+Show(jet(@a*@b,Mu)); |
---|
643 | "---"; |
---|
644 | "f1 * f2 - f = "+Show(jet(@a*@b - @f,Mu)); |
---|
645 | "---"; |
---|
646 | @JetId = x(1)^3 + x(2)^(3*@k); |
---|
647 | "Jf2 = "+Show(jet(@b, (3*@k), weight(@JetId))); |
---|
648 | "---"; |
---|
649 | @JetId = x(1) + x(2)^(@k); |
---|
650 | "Jf1 = "+Show(jet(@a, @k, weight(@JetId))); |
---|
651 | nameof(basering); |
---|
652 | basering; |
---|
653 | @b; |
---|
654 | "test-0"; |
---|
655 | milnor(@b); |
---|
656 | "test-1"; |
---|
657 | execute Setring(2); |
---|
658 | "test-2"; |
---|
659 | @s1 = "map CnV="+ @RestRing+ ",x(1), x(2);"; |
---|
660 | execute @s1; |
---|
661 | "test-3"; |
---|
662 | CnV(@b); |
---|
663 | "test-4"; |
---|
664 | milnor(CnV(@b)); |
---|
665 | "test-5"; |
---|
666 | if( defined(r) == 1) { "R ist definiert"; } |
---|
667 | "test-6"; |
---|
668 | @fkt,@Typ=Klassifiziere(CnV(@b)); |
---|
669 | "Klassifiziere-done"; |
---|
670 | @Typ,@kr,@rr,@sr=DecodeNormalFormString(@Typ); |
---|
671 | @Typ,"=",@kr,@rr,@sr; |
---|
672 | @r = @kr-@k; |
---|
673 | if( @Typ == "E[6k]" ) { return(Funktion42(@f, @k, @r)); } |
---|
674 | if( @Typ == "E[6k+1]" ) { return(Funktion43(@f, @k, @r)); } |
---|
675 | if( @Typ == "E[6k+2]" ) { return(Funktion44(@f, @k, @r)); } |
---|
676 | if( @Typ == "J[k,0]" ) { return(Funktion45(@f, @k, @r, @sr)); } |
---|
677 | if( @Typ == "J[k,r]" ) { return(Funktion45(@f, @k, @r, @sr)); } |
---|
678 | return("","Fehler!"); |
---|
679 | } |
---|
680 | //============================================================================= |
---|
681 | //============================================================================= |
---|
682 | //proc Funktion50 - put here |
---|
683 | //========================================================================= |
---|
684 | // Id: lib_WorkOn,v 1.6 1995/08/29 18:04:09 krueger Exp |
---|
685 | // |
---|
686 | // Please send bugs and comments to krueger@mathematik.uni-kl.de |
---|
687 | // |
---|
688 | //============================================================================= |
---|
689 | |
---|
690 | LIB "elim.lib"; |
---|
691 | |
---|
692 | //========================================================================= |
---|
693 | proc Funktion50 (poly @f, int corank) |
---|
694 | USAGE: Funktion50(); |
---|
695 | { |
---|
696 | poly @f3 = jet(@f, 3); |
---|
697 | debug_log(1, "Schritt 50"); |
---|
698 | if( @f3 == 0 ) { return(Funktion104(@f, corank)); } |
---|
699 | |
---|
700 | // f3 ~ |
---|
701 | ideal @Jf1 = jacob(@f3); |
---|
702 | ideal @Jf = std(@Jf1); |
---|
703 | ideal @Jf2; |
---|
704 | // "Jf1=",Show(@Jf[1]); |
---|
705 | // "Jf2=",Show(@Jf[2]); |
---|
706 | // "Jf3=",Show(@Jf[3]); |
---|
707 | int @Dim = dim(@Jf); |
---|
708 | int @Mult = mult(@Jf); |
---|
709 | "Dim=",@Dim," Mult=",@Mult," Jet3=", Show(@f3); |
---|
710 | |
---|
711 | if(@Dim == 0) { return(Funktion51(@f, corank)); } // x3 + y3 + z3 + axyz |
---|
712 | if(@Dim == 1) { |
---|
713 | if(@Mult == 2) { |
---|
714 | @Jf2 = wedge(jacob(@Jf1),3-@Dim), @Jf1; |
---|
715 | @Jf2 = std(@Jf2); |
---|
716 | @Dim = dim(@Jf2); |
---|
717 | @Mult = mult(@Jf2); |
---|
718 | "dim=", @Dim, "Mult=",@Mult," Jf2=", @Jf2; |
---|
719 | if (@Dim == 0) { return(Funktion54(@f, corank)); } // x3 + xyz |
---|
720 | if (@Dim == 1) { return(Funktion58(@f, corank)); } // x3 + yz2 |
---|
721 | } |
---|
722 | if(@Mult == 3) { |
---|
723 | @Jf2 = wedge(jacob(@Jf1),3-@Dim), @Jf1; |
---|
724 | @Jf2 = std(@Jf2); |
---|
725 | @Dim = dim(@Jf2); |
---|
726 | if(@Dim == 0) { return(Funktion56(@f, corank)); } // xyz |
---|
727 | if(@Dim == 1) { return(Funktion66(@f, corank)); } // x2z + yz2 |
---|
728 | } |
---|
729 | if(@Mult == 4) { return(Funktion82(@f, corank)); } // x3 + xz2 |
---|
730 | } |
---|
731 | if(@Dim == 2) { |
---|
732 | if(@Mult == 1) { return(Funktion97(@f, corank)); } // x2y |
---|
733 | if(@Mult == 2) { return(Funktion103(@f, corank)); } // x3 |
---|
734 | } |
---|
735 | if(@Dim == 3) { return(Funktion52(@f, corank)); } // x3 + y3 + xyz |
---|
736 | |
---|
737 | return("","Fehler!"); |
---|
738 | } |
---|
739 | //============================================================================= |
---|
740 | proc Funktion51 (poly @f, int @k) |
---|
741 | USAGE: Funktion51(); |
---|
742 | { |
---|
743 | string @s = "Die Singularitaet `"+Show(jet(@f, K)); |
---|
744 | string @tp = "P[8]=T[3,3,3]"; |
---|
745 | |
---|
746 | @s = @s +"' ist vom Typ "+@tp+"(F51), mu="+string(Mu)+", m="+string(@k-1); |
---|
747 | @s+" ("+SG_Typ+")"; |
---|
748 | return(Show(@f), @tp); |
---|
749 | } |
---|
750 | //============================================================================= |
---|
751 | proc Funktion52 (poly @f, int @k) |
---|
752 | USAGE: Funktion52(); |
---|
753 | { |
---|
754 | int @p = 4; |
---|
755 | string @s = "Die Singularitaet `"+Show(jet(@f, K)); |
---|
756 | string @tp = "P["+string(@p+5)+"]=T[3,3,"+string(@p+5)+"]"; |
---|
757 | |
---|
758 | @s = @s +"' ist vom Typ "+@tp+"(F52), mu="+string(Mu)+", m="+string(@k-1); |
---|
759 | @s+" ("+SG_Typ+")"; |
---|
760 | return(Show(@f), @tp); |
---|
761 | } |
---|
762 | //============================================================================= |
---|
763 | proc Funktion54 (poly @f, int @k) |
---|
764 | USAGE: Funktion54(); |
---|
765 | { |
---|
766 | int @p = 4; |
---|
767 | string @s = "Die Singularitaet `"+Show(jet(@f, K)); |
---|
768 | string @tp = "R[p,q]=T[3,p,q]"; |
---|
769 | |
---|
770 | @s = @s +"' ist vom Typ "+@tp+"(F54), mu="+string(Mu)+", m="+string(@k-1); |
---|
771 | @s+" ("+SG_Typ+")"; |
---|
772 | return(Show(@f), @tp); |
---|
773 | } |
---|
774 | //============================================================================= |
---|
775 | proc Funktion56 (poly @f, int @k) |
---|
776 | USAGE: Funktion56(); |
---|
777 | { |
---|
778 | int @p = 4; |
---|
779 | string @s = "Die Singularitaet `"+Show(jet(@f, K)); |
---|
780 | string @tp = "T[p,q,r]"; |
---|
781 | |
---|
782 | @s = @s +"' ist vom Typ "+@tp+"(F56), mu="+string(Mu)+", m="+string(@k-1); |
---|
783 | @s+" ("+SG_Typ+")"; |
---|
784 | return(Show(@f), @tp); |
---|
785 | } |
---|
786 | //============================================================================= |
---|
787 | proc Funktion58 (poly @fin, int @k) |
---|
788 | USAGE: Funktion58(); |
---|
789 | { |
---|
790 | poly @f = @fin; |
---|
791 | |
---|
792 | "Schritt 58"; |
---|
793 | poly @f3 = jet(@f, 3); |
---|
794 | string @tp="Nix"; |
---|
795 | int @kx = 1; // Koordinate x |
---|
796 | int @ky = 2; // Koordinate y |
---|
797 | int @kz = 3; // Koordinate z |
---|
798 | poly @a; |
---|
799 | poly @b; |
---|
800 | poly @phi; // Rest im Grad 3 |
---|
801 | ideal @B = maxideal(1); // ideal fuer Abbildungen |
---|
802 | ideal @Jf3 = jacob(@f3); |
---|
803 | ideal @S = sat(@Jf3, maxideal(1)); |
---|
804 | ideal @J1 = diff(@S[1], x(@kx)), diff(@S[1], x(@ky)), diff(@S[1], x(@kz)), |
---|
805 | diff(@S[2], x(@kx)), diff(@S[2], x(@ky)), diff(@S[2], x(@kz)); |
---|
806 | matrix @M[2][3] = @J1; |
---|
807 | ideal @J2 = minor(@M, 2), @S; |
---|
808 | //-------------------------------------------------------------- |
---|
809 | // Bestimme die Koordinate 'x' |
---|
810 | // |
---|
811 | @S = sat(@J2, maxideal(1)); |
---|
812 | @J1 = Coeff(@S[1], x(1), x(1)), Coeff(@S[1], x(2), x(2)), |
---|
813 | Coeff(@S[1], x(3), x(3)), Coeff(@S[2], x(1), x(1)), |
---|
814 | Coeff(@S[2], x(2), x(2)), Coeff(@S[2], x(3), x(3)); |
---|
815 | matrix @C[2][3] = @J1; |
---|
816 | matrix @D = syz(@C); |
---|
817 | kill @C; |
---|
818 | |
---|
819 | poly @b1 = @D[1,1]; |
---|
820 | poly @b2 = @D[2,1]; |
---|
821 | poly @b3 = @D[3,1]; |
---|
822 | |
---|
823 | if(DeBug>5) { "f3,s1=", Show(@f3); } |
---|
824 | if( @b1 != 0) { |
---|
825 | map VERT=basering,-1*@b1*x(1), -1*@b2*x(1)+x(2), -1*@b3*x(1) + x(3); |
---|
826 | @kx=1; @ky=2; @kz=3; |
---|
827 | } |
---|
828 | else { |
---|
829 | if( @b2 != 0) { |
---|
830 | map VERT=basering, x(1) + -1*@b1*x(2), -1*@b2*x(2), -1*@b3*x(2) + x(3); |
---|
831 | @kx=2; @ky=1; @kz=3; |
---|
832 | } |
---|
833 | else { |
---|
834 | if( @b3 != 0) { |
---|
835 | map VERT=basering, x(1) + -1*@b1*x(3), x(2) + -1*@b2*x(3), -1*@b3*x(3); |
---|
836 | @kx=3; @ky=1; @kz=2; |
---|
837 | } |
---|
838 | } |
---|
839 | } |
---|
840 | @f = VERT(@f); |
---|
841 | if(DeBug>5) { VERT; } |
---|
842 | @f3 = jet(@f,3); |
---|
843 | if(DeBug>5) { "f3,s2=", Show(@f3); } |
---|
844 | |
---|
845 | //-------------------------------------------------------------- |
---|
846 | // die Variable 'x' ist nun isoliert worden. d.h j3f = xf2+f3 |
---|
847 | // d.h Die rolle von 'x' ist nun bestimmt. |
---|
848 | // fuehre Koordinaten-transformation fuer f_2 aus. |
---|
849 | // |
---|
850 | if(DeBug>5) { "1) x=", @kx, " y=", @ky, " z=", @kz; } |
---|
851 | matrix @C = Coeffs(@f3, x(@kx)); |
---|
852 | @C; |
---|
853 | poly @fb=@C[2,1]; // Coeff von x^1 |
---|
854 | poly @fc=@C[1,1]; // Coeff von x^0 |
---|
855 | "f-2=", Show(@fb); |
---|
856 | "f-3=", Show(@fc); |
---|
857 | if(diff(@fb, x(@ky)) != 0) { |
---|
858 | kill VERT; |
---|
859 | ideal @Jfsyz = @fb, diff(@fb, x(@ky)); |
---|
860 | matrix @Mat = matrix(syz(@Jfsyz)); |
---|
861 | // @Mat; |
---|
862 | @B = maxideal(1); // setze Abbildungs-ideal |
---|
863 | if( nrows(@Mat) == 2) { |
---|
864 | poly @Relation = -2 * @Mat[2,1] / @Mat[1,1]; |
---|
865 | @b = Coeff(@Relation, x(@kz), x(@kz)); |
---|
866 | @B[rvar(x(@ky))] = x(@ky)-@b*x(@kz); |
---|
867 | } |
---|
868 | else { |
---|
869 | @Jfsyz = @fb, diff(@fb, x(@kz)); |
---|
870 | @Mat = matrix(syz(@Jfsyz)); |
---|
871 | poly @Relation = -2 * @Mat[2,1]; |
---|
872 | @a = Coeff(@Relation, x(@ky), x(@ky)); |
---|
873 | @B[rvar(x(@kz))] = x(@kz)-@a*x(@kz); |
---|
874 | @ky, @kz = swap(@ky, @kz); |
---|
875 | } |
---|
876 | map VERT=basering, @B; |
---|
877 | VERT; |
---|
878 | @f = VERT(@f); |
---|
879 | @f3 = jet(@f,3); |
---|
880 | kill @Mat; |
---|
881 | } |
---|
882 | else { @ky,@kz = swap(@ky,@kz); } |
---|
883 | "f3,s3=", Show(@f3); |
---|
884 | |
---|
885 | //-------------------------------------------------------------- |
---|
886 | // fuehre nun Tschirnhaus in der Variablen 'z' durch und erhalte |
---|
887 | // f = f_1(x,y,z)y^2 + z^3 |
---|
888 | // |
---|
889 | "2) x=", @kx, " y=", @ky, " z=", @kz; |
---|
890 | @C = Coeffs(@f3, x(@kx)); |
---|
891 | @fb=@C[2,1]; // Coeff von x^1 |
---|
892 | @fc=@C[1,1]; // Coeff von x^0 |
---|
893 | @fc, VERT = Tschirnhaus(@fc, x(@kz)); |
---|
894 | VERT; |
---|
895 | @f = VERT(@f); |
---|
896 | "-------------------------------------"; |
---|
897 | @f3 = jet(@f,3); |
---|
898 | "j3f,s5=",Show(@f3); |
---|
899 | "f=", Show(@f); |
---|
900 | |
---|
901 | //-------------------------------------------------------------- |
---|
902 | // fuehre Koordinaten-transformation fuer f_1 durch und erhalte |
---|
903 | // f=xy2 + z3 |
---|
904 | // |
---|
905 | "3) x=", @kx, " y=", @ky, " z=", @kz; |
---|
906 | // ACHTUNG Bug, fuer Sing22 |
---|
907 | Show(@f3 - 1*(Coeffs(@f3, x(@kz))[4,1])*x(@kz)^3); |
---|
908 | poly @fa; |
---|
909 | @fb = (@f3 - 1*(Coeffs(@f3, x(@kz))[4,1])*x(@kz)^3)/(x(@ky)^2); |
---|
910 | "fb=", Show(@fb); |
---|
911 | @fc = (x(@kx)-1*(Coeffs(@fb, x(@ky))[2,1])*x(@ky)-1*(Coeffs(@fb, x(@kz))[2,1])*x(@kz)); |
---|
912 | @fa = Coeffs(@fb, x(@kx))[2,1]; |
---|
913 | if ( @fa != 0 ) { |
---|
914 | @B = maxideal(1); |
---|
915 | @B[rvar(x(@kx))] = @fc / @fa; |
---|
916 | map VERT=basering, @B; |
---|
917 | VERT; |
---|
918 | @f = VERT(@f); |
---|
919 | @f3 = jet(@f,3); |
---|
920 | "j3f,s6=",Show(@f3); |
---|
921 | |
---|
922 | // map VERT = basering, x(4-@kx), x(4-@ky), x(4-@kz); |
---|
923 | // @f = VERT(@f); |
---|
924 | // map VERT = basering, x(1), x(3), x(2); |
---|
925 | // @f = VERT(@f); |
---|
926 | // @phi = jet(@f,3); |
---|
927 | // @f3 = jet(@f,3); |
---|
928 | // "j3f,s7=",Show(@phi); |
---|
929 | } |
---|
930 | |
---|
931 | |
---|
932 | //-------------------------------------------------------------- |
---|
933 | if(Coeffs(@f3, x(1))[4,1]!=0) { |
---|
934 | @kx=1; |
---|
935 | if(Coeffs(@f3, x(2))[3,1]==0) { @ky=2; @kz=3; } |
---|
936 | else { @ky=3; @kz=2; } |
---|
937 | } |
---|
938 | else { |
---|
939 | if(Coeffs(@f3, x(2))[4,1]!=0) { |
---|
940 | @kx=2; |
---|
941 | if(Coeffs(@f3, x(3))[3,1]==0) { @ky=3; @kz=1; } |
---|
942 | else { @ky=1; @kz=3; } |
---|
943 | } |
---|
944 | else { |
---|
945 | @kx=3; |
---|
946 | if(Coeffs(@f3, x(1))[3,1]==0) { @ky=1; @kz=2; } |
---|
947 | else { @ky=2; @kz=1; } |
---|
948 | } |
---|
949 | } |
---|
950 | "4) x=", @kx, " y=", @ky, " z=", @kz; |
---|
951 | map VERT = basering, x(@kx), x(@ky), x(@kz); |
---|
952 | @f = VERT(@f); |
---|
953 | @f3 = jet(@f,3); |
---|
954 | "j3f,s8=",Show(@f3); |
---|
955 | |
---|
956 | return(Funktion59(@f, @k)); |
---|
957 | } |
---|
958 | |
---|
959 | //============================================================================= |
---|
960 | proc Funktion59 (poly @f, int @k) |
---|
961 | USAGE: Funktion59(); |
---|
962 | { |
---|
963 | int @p = 1; |
---|
964 | string @tp="Nix"; |
---|
965 | poly @phi = jet(@f,3); |
---|
966 | poly @fr = @f - @phi; |
---|
967 | poly @fk; |
---|
968 | poly @alpha = coeffs(@fr, x(1))[1,1]; |
---|
969 | poly @beta = (@fr - @alpha) / x(1); |
---|
970 | ideal @JetId; |
---|
971 | intvec @w; |
---|
972 | |
---|
973 | "f = ", Show(@f); |
---|
974 | "fr = ", Show(@fr); |
---|
975 | "alpha= ", Show(@alpha); |
---|
976 | "beta = ", Show(@beta); |
---|
977 | |
---|
978 | while(@p<9) { |
---|
979 | "Schritt 59_", @p; |
---|
980 | @JetId = x(2)^(3*@p+1); weight(@JetId); |
---|
981 | @JetId = @phi + x(2)^(3*@p+1); |
---|
982 | @w = weight(@JetId); |
---|
983 | @fk = jet(@fr, 3*@w[1], @w); |
---|
984 | "a)", @p, 3*@w[1], Show(@fk), @w; |
---|
985 | if( @fk != 0 ) { return(Funktion60(@f,@p)); } |
---|
986 | |
---|
987 | @JetId = @phi + x(1)*x(2)^(2*@p+1); |
---|
988 | @w = weight(@JetId); |
---|
989 | @fk = jet(@fr, 3*@w[1], @w); |
---|
990 | "b)", @p, 3*@w[1], Show(@fk), @w; |
---|
991 | if( @fk != 0 ) { return(Funktion61(@f,@p)); } |
---|
992 | |
---|
993 | @JetId = @phi + x(2)^(3*@p+2); |
---|
994 | @w = weight(@JetId); |
---|
995 | @fk = jet(@fr, 3*@w[1], @w); |
---|
996 | "c)", @p, 3*@w[1], Show(@fk), @w; |
---|
997 | if( @fk != 0 ) { return(Funktion62(@f,@p)); } |
---|
998 | |
---|
999 | @p = @p+1; // Weiter mit Funktion 63 fuer p eins groesser |
---|
1000 | @JetId = @phi + x(2)^(3*@p); |
---|
1001 | @w = weight(@JetId); |
---|
1002 | @fk = jet(@f, 3*@w[1], @w); |
---|
1003 | "d)", @p, 3*@w[1], Show(@fk), @w; |
---|
1004 | // if( @fk != 0 ) { |
---|
1005 | @JetId = jacob(@fk); |
---|
1006 | @JetId = std(@JetId); |
---|
1007 | int @Dim = dim(@JetId); |
---|
1008 | int @Mult = mult(@JetId); |
---|
1009 | "Dim=",@Dim," Mult=",@Mult," Jetk=", Show(@fk); |
---|
1010 | if(@Dim == 0) { return(Funktion64(@f,@p)); } |
---|
1011 | if(@Dim == 1) { |
---|
1012 | if(@Mult == 1) { return(Funktion65(@f,@p)); } |
---|
1013 | if(@Mult == 2) { |
---|
1014 | "Faktorisiere"; |
---|
1015 | @fk = jet(@fr, 3*@w[1], @w); |
---|
1016 | poly @tt=Coeffs(@phi, x(1))[4,1] *x(1)^3+@fk; |
---|
1017 | intvec RFlg=1,2,3; |
---|
1018 | export RFlg; |
---|
1019 | RFlg; |
---|
1020 | "tt=",Show(@tt); |
---|
1021 | "f=",Show(@f); |
---|
1022 | @f = Faktorisiere(@f, @tt, 3 , @p); |
---|
1023 | PhiG; |
---|
1024 | "f=",Show(@f); |
---|
1025 | @fr = @f - @phi; |
---|
1026 | } |
---|
1027 | } |
---|
1028 | // } |
---|
1029 | } |
---|
1030 | return(Show(@f), @tp); |
---|
1031 | } |
---|
1032 | |
---|
1033 | //============================================================================= |
---|
1034 | proc Funktion66 (poly @f, int @k) |
---|
1035 | USAGE: Funktion66(); |
---|
1036 | { |
---|
1037 | int @kx = 1; // Koordinate x |
---|
1038 | int @ky = 2; // Koordinate y |
---|
1039 | int @kz = 3; // Koordinate z |
---|
1040 | poly @f3 = jet(@f, 3); |
---|
1041 | ideal @JetId; |
---|
1042 | |
---|
1043 | debug_log(1, "Weiter-66"); |
---|
1044 | debug_log(2, "F3=", Show(@f3)); |
---|
1045 | poly @fx = diff(@f3, x(@kx)); |
---|
1046 | @JetId = jacob(@fx); |
---|
1047 | @JetId = std(@JetId); |
---|
1048 | "nach x:",Show(@fx), " Id=", @JetId, " Dim=", dim(@JetId); |
---|
1049 | |
---|
1050 | poly @fy = diff(@f3, x(@ky)); |
---|
1051 | @JetId = jacob(@fx); |
---|
1052 | @JetId = std(@JetId); |
---|
1053 | "nach y:",Show(@fy), " Id=", @JetId, " Dim=", dim(@JetId); |
---|
1054 | |
---|
1055 | poly @fz = diff(@f3, x(@kz)); |
---|
1056 | @JetId = jacob(@fx); |
---|
1057 | @JetId = std(@JetId); |
---|
1058 | "nach z:",Show(@fz), " Id=", @JetId, " Dim=", dim(@JetId); |
---|
1059 | } |
---|
1060 | //============================================================================= |
---|
1061 | proc Funktion82 (poly @f, int @k) |
---|
1062 | USAGE: Funktion82(); |
---|
1063 | { |
---|
1064 | poly @f3 = jet(@f,3); |
---|
1065 | int @kx = 1; // Koordinate x |
---|
1066 | int @ky = 2; // Koordinate y |
---|
1067 | int @kz = 3; // Koordinate z |
---|
1068 | poly @b1, @b2, @b3; |
---|
1069 | intvec @kv = 1,2,3; |
---|
1070 | int @i; |
---|
1071 | ideal @Jfsyz = jacob(@f3); |
---|
1072 | matrix @Mat; |
---|
1073 | int @Fall = 2; |
---|
1074 | |
---|
1075 | debug_log(1, "Schritt 82"); |
---|
1076 | if (diff(@f3, x(1)) == 0) { @kx, @ky = swap(@kx, @ky); } |
---|
1077 | if (diff(@f3, x(2)) == 0) { } |
---|
1078 | if (diff(@f3, x(3)) == 0) { @kz, @ky = swap(@kz, @ky); } |
---|
1079 | if ( (diff(@f3, x(1)) != 0) && (diff(@f3, x(2)) != 0) && |
---|
1080 | (diff(@f3, x(3)) != 0) ) { |
---|
1081 | @Mat = matrix(syz(@Jfsyz)); |
---|
1082 | @b1 = @Mat[1,1]; |
---|
1083 | @b2 = @Mat[2,1]; |
---|
1084 | @b3 = @Mat[3,1]; |
---|
1085 | |
---|
1086 | debug_log(2, @Mat); |
---|
1087 | if( @b1 != 0) { |
---|
1088 | map VERT=basering,@b1*x(@kx), @b2*x(@kx)+x(@ky), @b3*x(@kx) + x(@kz); |
---|
1089 | @f = VERT(@f); |
---|
1090 | @kx, @ky = swap(@kx, @ky); |
---|
1091 | } |
---|
1092 | else { |
---|
1093 | if( @b2 != 0) { |
---|
1094 | map VERT=basering,x(@kx) + @b1*x(@ky), @b2*x(@ky), @b3*x(@ky) + x(@kz); |
---|
1095 | @f = VERT(@f); |
---|
1096 | } |
---|
1097 | else { |
---|
1098 | if( @b3 != 0) { |
---|
1099 | map VERT=basering,x(@kx)+ @b1*x(@kz), x(@ky)+ @b2*x(@kz), @b3*x(@kz); |
---|
1100 | @f = VERT(@f); |
---|
1101 | } |
---|
1102 | } |
---|
1103 | } |
---|
1104 | debug_log(2, VERT); |
---|
1105 | } |
---|
1106 | // else { |
---|
1107 | map VERT=basering,x(@kx),x(@ky),x(@kz); |
---|
1108 | debug_log(2, VERT); |
---|
1109 | @f = VERT(@f); |
---|
1110 | // } |
---|
1111 | @f3 = jet(@f,3); |
---|
1112 | if ( defined(VERT) == 1) { kill VERT; } |
---|
1113 | if( (@f3-subst(@f3, x(@kx), 0)) == 0) { @kx, @ky = swap(@kx, @ky); } |
---|
1114 | if( (@f3-subst(@f3, x(@kz), 0)) == 0) { @kz, @ky = swap(@kz, @ky); } |
---|
1115 | debug_log(2, "1)f??=", Show(@f3)); |
---|
1116 | debug_log(2, "1)f3=", Show(@f)); |
---|
1117 | //------------------------------------------------------ |
---|
1118 | debug_log(2, size(coeffs(@f3, x(@kx)))); |
---|
1119 | // if (size(coeffs(@f3, x(@kx))) == 3) { |
---|
1120 | matrix @C = coeffs(@f3, x(@kx)); |
---|
1121 | debug_log(2, @C); |
---|
1122 | if(size(@C) == 3) { @C = coeffs(@f3, x(@kz)); } |
---|
1123 | if(@C[1,1] == 0 && @C[3,1] == 0) { @Fall = 1; } |
---|
1124 | if(@C[1,1] != 0 && @C[3,1] != 0 ) { @Fall = 3; } |
---|
1125 | if(@C[1,1] == 0 && @C[3,1] != 0 ) { @Fall = 2; } |
---|
1126 | if(@C[1,1] != 0 && @C[3,1] == 0 ) { @Fall = 2; @kx, @kz = swap(@kx, @kz); } |
---|
1127 | |
---|
1128 | debug_log(2, @C); |
---|
1129 | debug_log(2, "Fall: ", @Fall, " x=", @kx, " z=", @kz); |
---|
1130 | map VERT; |
---|
1131 | if(@Fall == 2) { @b1, VERT = Tschirnhaus(@f3/x(@kz), x(@kx)); } |
---|
1132 | else { |
---|
1133 | @b1, VERT = Tschirnhaus(@f3/x(@kx), x(@kx)); |
---|
1134 | debug_log(2, "B1=", Show(jet(VERT(@f),3))); |
---|
1135 | @b2, VERT = Tschirnhaus(@f3/x(@kz), x(@kz)); |
---|
1136 | debug_log(2, "B2=", Show(jet(VERT(@f),3))); |
---|
1137 | } |
---|
1138 | @f = VERT(@f); |
---|
1139 | @f3 = jet(@f,3); |
---|
1140 | debug_log(2, "2)f3=", Show(@f3)); |
---|
1141 | // @f3, VERT = Tschirnhaus(@f3, x(1)); |
---|
1142 | debug_log(2, "3)f3=", Show(jet(@f,3))); |
---|
1143 | // } |
---|
1144 | |
---|
1145 | @C = coeffs(@f3, x(1)); |
---|
1146 | if( @C[1,1] == 0 && @C[2,1] != 0 && @C[3,1] == 0 && @C[4,1] != 0 ) { |
---|
1147 | Funktion83(@f, @k); |
---|
1148 | } |
---|
1149 | return("", "Fehler"); |
---|
1150 | } |
---|
1151 | //============================================================================= |
---|
1152 | proc Isomorphie_s82_z (poly @f, poly @fk, int @p) |
---|
1153 | USAGE: Isomorphie_s82_z(); |
---|
1154 | { |
---|
1155 | matrix @Mat; |
---|
1156 | poly @Relation, @a, @b; |
---|
1157 | ideal @Jfsyz, @B; |
---|
1158 | |
---|
1159 | debug_log(1, " Isomorphie 82/90 z"); |
---|
1160 | debug_log(2, "tt=", Show(@fk)); |
---|
1161 | @Jfsyz = @fk, diff(@fk, x(3)); |
---|
1162 | @Mat = matrix(syz(@Jfsyz)); |
---|
1163 | @Relation = -2 * @Mat[2,1] / @Mat[1,1]; |
---|
1164 | @a = Coeff(@Relation, x(3), x(3)); |
---|
1165 | @b = Coeff(@Relation, x(2), x(2)^@p); |
---|
1166 | @B = maxideal(1); |
---|
1167 | @B[rvar(x(3))] = x(3)-@b*x(2)^@p; |
---|
1168 | map VERT=basering,@B; |
---|
1169 | @f = VERT(@f); |
---|
1170 | debug_log(2, VERT); |
---|
1171 | debug_log(2, " z res=", Show(VERT(@fk))); |
---|
1172 | return(@f); |
---|
1173 | } |
---|
1174 | |
---|
1175 | //============================================================================= |
---|
1176 | proc Isomorphie_s82_x (poly @f, poly @fk, int @p) |
---|
1177 | USAGE: Isomorphie_s82_x(); |
---|
1178 | { |
---|
1179 | matrix @Mat; |
---|
1180 | poly @Relation, @a, @b; |
---|
1181 | ideal @Jfsyz, @B; |
---|
1182 | |
---|
1183 | debug_log(1, " Isomorphie 82/90 x"); |
---|
1184 | debug_log(2, "tt=", Show(@fk)); |
---|
1185 | @Jfsyz = @fk, diff(@fk, x(1)); |
---|
1186 | @Mat = matrix(syz(@Jfsyz)); |
---|
1187 | @Relation = -3 * @Mat[2,1] / @Mat[1,1]; |
---|
1188 | @a = Coeff(@Relation, x(1), x(1)); |
---|
1189 | @b = Coeff(@Relation, x(2), x(2)^@p); |
---|
1190 | @B = maxideal(1); |
---|
1191 | @B[rvar(x(1))] = x(1)-@b*x(2)^@p; |
---|
1192 | map VERT=basering,@B; |
---|
1193 | @f = VERT(@f); |
---|
1194 | debug_log(2, VERT); |
---|
1195 | debug_log(2, " x res=", Show(VERT(@fk))); |
---|
1196 | |
---|
1197 | return(@f); |
---|
1198 | } |
---|
1199 | //============================================================================= |
---|
1200 | proc Funktion83 (poly @f, int @k) |
---|
1201 | USAGE: Funktion83(); |
---|
1202 | { |
---|
1203 | int @p = 1; |
---|
1204 | ideal @JetId; |
---|
1205 | poly @fk; |
---|
1206 | intvec @w; |
---|
1207 | ideal @Jf; |
---|
1208 | poly @phi; |
---|
1209 | int @Dim, @Mult; |
---|
1210 | matrix @Mat; |
---|
1211 | poly @a, @b; |
---|
1212 | ideal @B; |
---|
1213 | |
---|
1214 | debug_log(1, " Schritt 83"); |
---|
1215 | while(@p<10) { |
---|
1216 | debug_log(1, " Schritt 83_"+string(@p)); |
---|
1217 | @phi = jet(@f, 3); |
---|
1218 | @JetId = x(1)^3 + x(3)^3 + x(2)^(3*@p+1); weight(@JetId); |
---|
1219 | @w = weight(@JetId); |
---|
1220 | @fk = jet(@f- @phi, 3*@w[1], @w) ; |
---|
1221 | debug_log(2, "a)", @p, 3*@w[1], Show(@fk), @w, Show(@phi)); |
---|
1222 | if( @fk != 0 ) { return(Funktion84(@f,@p)); } |
---|
1223 | |
---|
1224 | @JetId = x(1)^3 + x(3)^3 + x(1)*x(2)^(2*@p+1); weight(@JetId); |
---|
1225 | @w = weight(@JetId); |
---|
1226 | @fk = jet(@f, 3*@w[1], @w) ; |
---|
1227 | debug_log(2, "b)", @p, 3*@w[1], Show(@fk), @w, Show(@phi)); |
---|
1228 | if ( @fk != @phi ) { |
---|
1229 | @Jf=std(jacob(@fk)); |
---|
1230 | @Dim = dim(@Jf); |
---|
1231 | @Mult = mult(@Jf); |
---|
1232 | debug_log(2, "85-ft="+Show(@fk)+" Dim="+string(@Dim)+" mult="+string(@Mult)); |
---|
1233 | if ( @Dim == 0 ) { return(Funktion86(@f,@p)); } |
---|
1234 | if ( @Dim == 1 ) { return(Funktion87(@f,@p)); } |
---|
1235 | } |
---|
1236 | |
---|
1237 | @JetId = x(1)^3 + x(3)^3 + x(2)^(3*@p+2); weight(@JetId); |
---|
1238 | @w = weight(@JetId); |
---|
1239 | @fk = jet(@f- @phi, 3*@w[1], @w) ; |
---|
1240 | debug_log(2, "c)", @p, 3*@w[1], Show(@fk), @w, Show(@phi)); |
---|
1241 | if( @fk != 0 ) { return(Funktion89(@f,@p)); } |
---|
1242 | |
---|
1243 | @p = @p + 1; |
---|
1244 | @JetId = x(1)^3 + x(3)^3 + x(2)^(3*@p); weight(@JetId); |
---|
1245 | @w = weight(@JetId); |
---|
1246 | @fk = jet(@f, 3*@w[1], @w) ; |
---|
1247 | @Jf=std(jacob(@fk)); |
---|
1248 | @Dim = dim(@Jf); |
---|
1249 | @Mult = mult(@Jf); |
---|
1250 | debug_log(2, "90 - ft="+Show(@fk)+" Dim="+string(@Dim)+" mult="+string(@Mult)); |
---|
1251 | if ( @Dim == 0 ) { } |
---|
1252 | if ( @Dim == 1 ) { |
---|
1253 | if ( @Mult == 4 ) { |
---|
1254 | if( @fk - @phi != 0) { // b!=0 und/oder b'!=0 |
---|
1255 | if( Coeff(@fk,x(1)*x(2), x(1)^2*x(2)^@p) == 0 ) { // b=0 und b'!=0 |
---|
1256 | @a=(@fk - Coeff(@fk, x(1), x(1)^3)*x(1)^3) / x(1); |
---|
1257 | @f = Isomorphie_s82_z(@f, @a, @p); |
---|
1258 | } |
---|
1259 | else { |
---|
1260 | if( Coeff(@fk,x(1)*x(2)*x(3), x(1)*x(2)^@p*x(3)) == 0 ){ |
---|
1261 | // b!=0 und b'=0 |
---|
1262 | debug_log(2, "Fall b'=2"); |
---|
1263 | @a=subst(@fk, x(3), 0); |
---|
1264 | @f = Isomorphie_s82_x(@f, @a, @p); |
---|
1265 | } |
---|
1266 | else { |
---|
1267 | @a = Coeff(@fk,x(1)*x(2)*x(3), x(1)*x(2)^@p*x(3)); |
---|
1268 | @b = Coeff(@fk,x(2)*x(3), x(2)^(2*@p)*x(3)); |
---|
1269 | @B = maxideal(1); |
---|
1270 | @B[rvar(x(1))] = x(1)-@b/@a*x(2)^@p; |
---|
1271 | map VERT=basering,@B; |
---|
1272 | @f = VERT(@f); |
---|
1273 | @fk = jet(@f, 3*@w[1], @w) ; |
---|
1274 | debug_log(2, VERT); |
---|
1275 | |
---|
1276 | @a=(@fk - Coeff(@fk, x(1), x(1)^3)*x(1)^3) / x(1); |
---|
1277 | @f = Isomorphie_s82_z(@f, @a, @p); |
---|
1278 | } // ende else b!=0 und b'=0 |
---|
1279 | } // ende else b=0 und b'!=0 |
---|
1280 | } //ende @fk-@phi!=0 |
---|
1281 | } // ende mult=4 |
---|
1282 | } // ende dim=1 |
---|
1283 | } // ENDE While |
---|
1284 | return("", "Fehler"); |
---|
1285 | } |
---|
1286 | |
---|
1287 | //============================================================================= |
---|
1288 | proc Funktion97 (poly @f, int @K) |
---|
1289 | USAGE: Funktion97(); |
---|
1290 | { |
---|
1291 | int @kx = 1; // Koordinate x |
---|
1292 | int @ky = 2; // Koordinate y |
---|
1293 | int @kz = 3; // Koordinate z |
---|
1294 | ideal @B = maxideal(1); // Abbildungs-ideal |
---|
1295 | |
---|
1296 | int @k = 2; |
---|
1297 | int @i; |
---|
1298 | int @pt = 2; |
---|
1299 | poly @f3 = jet(@f, 3); |
---|
1300 | ideal @Jfsyz; |
---|
1301 | |
---|
1302 | poly @l1; |
---|
1303 | poly @l2; |
---|
1304 | poly @a; |
---|
1305 | poly @b; |
---|
1306 | poly @c; |
---|
1307 | poly @prod; |
---|
1308 | matrix @Mat; |
---|
1309 | int @k = 1; |
---|
1310 | |
---|
1311 | "Weiter-97"; |
---|
1312 | "Jet3 = ", Show(@f3); |
---|
1313 | // vertausche 2 Koordinaten sodass d2f/dx2 <>0 ist. |
---|
1314 | for(@i=1;@i<4;@i=@i+1) { |
---|
1315 | if(diff(diff(@f3, x(@i)), x(@i)) != 0) { @kx = @i; @i=4; } |
---|
1316 | } |
---|
1317 | if(@kx == 2) { @ky = 1; @kz = 3; } |
---|
1318 | if(@kx == 3) { @ky = 2; @kz = 1; } |
---|
1319 | |
---|
1320 | // bereche -l1l2 und anschliessend l1 |
---|
1321 | @f3 = jet(@f, 3); |
---|
1322 | @Jfsyz = @f3, diff(@f3, x(@kx)); |
---|
1323 | @Mat = matrix(syz(@Jfsyz)); |
---|
1324 | @Jfsyz = @f3, @Mat[2,1]; |
---|
1325 | @Mat = matrix(syz(@Jfsyz)); |
---|
1326 | |
---|
1327 | // berechen Abb. sodass f=x2*l2 |
---|
1328 | @l1 = @Mat[2,1]; |
---|
1329 | @a = Coeff(@l1, x(@kx), x(@kx)); |
---|
1330 | @l1 = @l1 / number(@a); |
---|
1331 | @b = Coeff(@l1, x(@ky), x(@ky)); |
---|
1332 | @c = Coeff(@l1, x(@kz), x(@kz)); |
---|
1333 | @B[rvar(x(@kx))] = x(@kx) - @b * x(@ky) - @c * x(@kz); |
---|
1334 | map VERT=basering, @B; |
---|
1335 | @f = VERT(@f); |
---|
1336 | kill VERT; |
---|
1337 | @f3 = jet(@f, 3); |
---|
1338 | |
---|
1339 | "Jet3=", Show(@f3); |
---|
1340 | @l2 = @f3 / x(@kx)^2; |
---|
1341 | "l2=", @l2; |
---|
1342 | |
---|
1343 | // sorge dafuer, dass b<>0 ist. |
---|
1344 | @b = Coeff(@l2, x(@ky), x(@ky)); |
---|
1345 | if( @b== 0) { |
---|
1346 | @ky, @kz = swap(@ky, @kz); |
---|
1347 | } |
---|
1348 | |
---|
1349 | // Koordinaten-Transf. s.d. f=x2y |
---|
1350 | @b = Coeff(@l2, x(@ky), x(@ky)); |
---|
1351 | @l2 = @l2 / number(@b); |
---|
1352 | @a = Coeff(@l2, x(@kx), x(@kx)); |
---|
1353 | @c = Coeff(@l2, x(@kz), x(@kz)); |
---|
1354 | @B = maxideal(1); |
---|
1355 | @B[rvar(x(@ky))] = -@a * x(@kx) + x(@ky) - @c * x(@kz); |
---|
1356 | map VERT=basering, @B; |
---|
1357 | @f = VERT(@f); |
---|
1358 | kill VERT; |
---|
1359 | |
---|
1360 | // bereche gewichteten jet von f |
---|
1361 | @f3 = jet(@f, 3); |
---|
1362 | "Jet3=", Show(@f3); |
---|
1363 | @Jfsyz = x(@kx)^2*x(@ky) + x(@ky)^4 + x(@kz)^4; |
---|
1364 | @a = jet(@f, 8, weight(@Jfsyz)); |
---|
1365 | // der Gewichtete Jet betsteht nun aus den Monomen: |
---|
1366 | // x2y, y4, y4z, y2z2, yz3, z4, x2z |
---|
1367 | "a=", Show(@a); |
---|
1368 | |
---|
1369 | ideal @Jf=jacob(@a); |
---|
1370 | ideal @j1=std(@Jf); |
---|
1371 | int @Dim=dim(@j1); |
---|
1372 | int @Mult=mult(@j1); |
---|
1373 | if( @Dim == 0) { return(Show(@f), "V[1,0]"); } |
---|
1374 | if( @Dim == 1) { |
---|
1375 | if( @Mult == 1 ) { return(Funktion100(@f, @K)); } |
---|
1376 | if( @Mult == 2 ) { return(Funktion101(@f, @K)); } |
---|
1377 | } |
---|
1378 | " Dim=",@Dim," Dim2=",dim(@j2)," Mult=",@Mult," Mult2=",mult(@j2); |
---|
1379 | return(Show(@f), "V[k,r]"); |
---|
1380 | } |
---|
1381 | //============================================================================= |
---|
1382 | proc Funktion103 (poly @f) |
---|
1383 | USAGE: Funktion103(); |
---|
1384 | { |
---|
1385 | return(FunktionNoClass(@f,"3-jet = x3")); |
---|
1386 | } |
---|
1387 | //============================================================================= |
---|
1388 | proc Funktion104 (poly @f) |
---|
1389 | USAGE: Funktion104(); |
---|
1390 | { |
---|
1391 | return(FunktionNoClass(@f)); |
---|
1392 | } |
---|
1393 | //============================================================================= |
---|
1394 | proc Funktion105 (poly @f); |
---|
1395 | USAGE: Funktion105(); |
---|
1396 | { |
---|
1397 | return(FunktionNoClass(@f)); |
---|
1398 | } |
---|
1399 | //============================================================================= |
---|
1400 | proc FunktionNoClass (poly @f, list #) |
---|
1401 | USAGE: FunktionNoClass(); |
---|
1402 | |
---|
1403 | { |
---|
1404 | if(size(#)==2) { string @txt=#[2]; } |
---|
1405 | |
---|
1406 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1407 | @s = @s +"' is not in Arnolds list."+newline; |
---|
1408 | if(size(#)==2) { @s = @s + @txt; } |
---|
1409 | @s = @s + ", Milnor number = " + string(Mu); |
---|
1410 | |
---|
1411 | return(Show(@f), @s); |
---|
1412 | } |
---|
1413 | //============================================================================= |
---|
1414 | //============================================================================= |
---|
1415 | proc Tschirnhaus (poly @f, poly @x) |
---|
1416 | USAGE: Tschirnhaus(); |
---|
1417 | { |
---|
1418 | int @n = nvars(basering); |
---|
1419 | int @j; |
---|
1420 | |
---|
1421 | // "Tschirnhaus fuer:", Show(@f); |
---|
1422 | matrix @cf = coeffs(@f, @x); |
---|
1423 | int @hc = nrows(@cf) - 1; // hoechster exponent von x_i |
---|
1424 | poly @b = @cf[@hc+1,1]; // koeffizient von x_i^hc |
---|
1425 | ideal @B = maxideal(1); |
---|
1426 | |
---|
1427 | string @s="map @EH="+nameof(basering); |
---|
1428 | for( @j=1; @j<=@n ; @j=@j+1) { @s = @s + ",0"; } |
---|
1429 | @s = @s + ";"; |
---|
1430 | execute @s; |
---|
1431 | "b=", @b; |
---|
1432 | "EH(b)=", @EH(@b); |
---|
1433 | |
---|
1434 | if ( @EH(@b) == 0) // pruefe ob der Koeff von x_i^hc |
---|
1435 | { map @Phi =basering, @B; |
---|
1436 | return(@f, @Phi); |
---|
1437 | } |
---|
1438 | @B[rvar(@x)] = @x -1*(@cf[@hc,1]/(@hc*@b)); |
---|
1439 | map @Phi =basering, @B; |
---|
1440 | return(@Phi(@f), @Phi); |
---|
1441 | } |
---|
1442 | //============================================================================= |
---|
1443 | //============================================================================= |
---|
1444 | proc Isomorphie_s17 (poly @f, poly @fk, int @k, int @ct) |
---|
1445 | USAGE: Isomorphie_s17(); |
---|
1446 | { |
---|
1447 | ideal @Jfsyz; |
---|
1448 | poly @Relation; |
---|
1449 | poly @a, @b, @c, @d; |
---|
1450 | ideal @JetId; |
---|
1451 | matrix @Matx, @Maty; |
---|
1452 | |
---|
1453 | // Ziel: bestimme a,b,c,d sodass @fk = (ax+by^k)^3(cx+dy) gilt. |
---|
1454 | debug_log(2, "Isomorphie_s17:"); |
---|
1455 | debug_log(2, "Faktor: f=",Show(@f)," Jet=",Show(@fk)," k=",@k); |
---|
1456 | |
---|
1457 | if( defined(VERT) == 1) { kill VERT; } |
---|
1458 | // "Fak-1:",Show(@f)," jet=",Show(@fk); |
---|
1459 | |
---|
1460 | if( @k == 1) { |
---|
1461 | @Jfsyz = @fk, diff(@fk, x(1)); |
---|
1462 | @Matx = matrix(syz(@Jfsyz)); |
---|
1463 | @Jfsyz = @fk, diff(@fk, x(2)); |
---|
1464 | @Maty = matrix(syz(@Jfsyz)); |
---|
1465 | |
---|
1466 | @a = Coeff(@fk, x(1), x(1)^4); |
---|
1467 | @b = Coeff(@fk, x(2), x(2)^4); |
---|
1468 | @c = Coeff(@fk, x(1)*x(2), x(1)^3*x(2)); |
---|
1469 | @d = Coeff(@fk, x(1)*x(2), x(1)*x(2)^3); |
---|
1470 | |
---|
1471 | if( (@a != 0) && (@b != 0) ) { |
---|
1472 | int @B,@C, @alpha, @beta, @gamma, @g; |
---|
1473 | poly @an, @bn; |
---|
1474 | |
---|
1475 | if(DeBug>7) { |
---|
1476 | Coeff(@Matx[1,1], x(2), x(2)); |
---|
1477 | Coeff(@Maty[1,1], x(1), x(1)); |
---|
1478 | Coeff(@Matx[2,1], x(1), x(1)^2); |
---|
1479 | Coeff(@Matx[2,1], x(1)*x(2), x(1)*x(2)); |
---|
1480 | Coeff(@Matx[2,1], x(2), x(2)^2); |
---|
1481 | } |
---|
1482 | @B = -int(Coeff(@Matx[1,1], x(2), x(2))); |
---|
1483 | @C = -int(Coeff(@Maty[1,1], x(1), x(1))); |
---|
1484 | @alpha = int(Coeff(@Matx[2,1], x(1), x(1)^2)); |
---|
1485 | @beta = int(Coeff(@Matx[2,1], x(1)*x(2), x(1)*x(2))); |
---|
1486 | @gamma = int(Coeff(@Matx[2,1], x(2), x(2)^2)); |
---|
1487 | |
---|
1488 | if(DeBug>7) { |
---|
1489 | "B=", @B; |
---|
1490 | "C=", @C; |
---|
1491 | "alpha=", @alpha; |
---|
1492 | "beta =", @beta; |
---|
1493 | "gamma=", @gamma; |
---|
1494 | |
---|
1495 | "(@B-@beta)/2=", (@B-@beta)/2; |
---|
1496 | "(@C-@beta)/2=", (@C-@beta)/2; |
---|
1497 | } |
---|
1498 | // @a = gcd((@B-@beta)/2, @alpha); |
---|
1499 | // @b = gcd((@C-@beta)/2, @gamma); |
---|
1500 | map VERT=basering,(x(1) - 2*(@gamma / (@B - @beta))*x(2)),x(2); |
---|
1501 | @Relation = VERT(@f); |
---|
1502 | @fk = jet(@Relation, 4); |
---|
1503 | |
---|
1504 | @an = Coeff(@fk, x(1), x(1)^4); |
---|
1505 | @bn = Coeff(@fk, x(2), x(2)^4); |
---|
1506 | if( (@an != 0) & (@bn != 0) ) { |
---|
1507 | VERT=basering,x(1),(x(2) + @a*x(1))/ @b; |
---|
1508 | } |
---|
1509 | |
---|
1510 | @f = VERT(@f); |
---|
1511 | @fk = jet(@f, 4); |
---|
1512 | PhiG = VERT(PhiG); |
---|
1513 | |
---|
1514 | @a = Coeff(@fk, x(1), x(1)^4); |
---|
1515 | @b = Coeff(@fk, x(2), x(2)^4); |
---|
1516 | @c = Coeff(@fk, x(1)*x(2), x(1)^3*x(2)); |
---|
1517 | @d = Coeff(@fk, x(1)*x(2), x(1)*x(2)^3); |
---|
1518 | @Jfsyz = @fk, diff(@fk, x(1)); |
---|
1519 | @Matx = matrix(syz(@Jfsyz)); |
---|
1520 | @Jfsyz = @fk, diff(@fk, x(2)); |
---|
1521 | @Maty = matrix(syz(@Jfsyz)); |
---|
1522 | } |
---|
1523 | |
---|
1524 | if( (@a == 0) || (@b == 0) ) { |
---|
1525 | if( @a == 0) { |
---|
1526 | if( @c == 0) { // y3(ax+by) |
---|
1527 | @Relation = - @Matx[2,1] / @Matx[1,1]; |
---|
1528 | @a = Coeff(@Relation, x(1), x(1)); |
---|
1529 | @b = Coeff(@Relation, x(2), x(2)); |
---|
1530 | map VERT=basering,@a*x(2)^@k - @b*x(1), x(1); |
---|
1531 | } |
---|
1532 | else { // (ax+by)^3y |
---|
1533 | @Relation = - 3*@Matx[2,1] / @Matx[1,1]; |
---|
1534 | @a = Coeff(@Relation, x(1), x(1)); |
---|
1535 | @b = Coeff(@Relation, x(2), x(2)); |
---|
1536 | map VERT=basering,@a*x(1) - @b*x(2), x(2); |
---|
1537 | } |
---|
1538 | } |
---|
1539 | else { |
---|
1540 | if( @d == 0) { // x3(ax+by) |
---|
1541 | @Relation = - @Maty[2,1] / @Maty[1,1]; |
---|
1542 | @a = Coeff(@Relation, x(1), x(1)); |
---|
1543 | @b = Coeff(@Relation, x(2), x(2)); |
---|
1544 | map VERT=basering,x(1), @b*x(2)^@k - @a*x(1); |
---|
1545 | } |
---|
1546 | else { // x(ax+by)^3 |
---|
1547 | @Relation = - 3*@Maty[2,1] / @Maty[1,1]; |
---|
1548 | @a = Coeff(@Relation, x(1), x(1)); |
---|
1549 | @b = Coeff(@Relation, x(2), x(2)); |
---|
1550 | map VERT=basering,x(2), @b*x(1) - @a*x(2); |
---|
1551 | } |
---|
1552 | } |
---|
1553 | @f = VERT(@f); |
---|
1554 | PhiG = VERT(PhiG); |
---|
1555 | } |
---|
1556 | else { |
---|
1557 | // "Weder b noch a sind 0"; |
---|
1558 | if(@ct > 5) { return(@f); } |
---|
1559 | @fk = jet(@f, 4); |
---|
1560 | return(Isomorphie_s17(@f, @fk, @k, @ct+1)); |
---|
1561 | } |
---|
1562 | } |
---|
1563 | else { // @k >1 |
---|
1564 | @a = @fk/x(2); |
---|
1565 | @Jfsyz = @a, diff(@a, x(1)); |
---|
1566 | @Matx = matrix(syz(@Jfsyz)); |
---|
1567 | @Relation = -3 * @Matx[2,1] / @Matx[1,1]; |
---|
1568 | // @Matx; |
---|
1569 | @a = Coeff(@Relation, x(1), x(1)); |
---|
1570 | @b = Coeff(@Relation, x(2), x(2)^@k); |
---|
1571 | map VERT=basering,x(1)-@b*x(2)^@k,x(2); |
---|
1572 | @f = VERT(@f); |
---|
1573 | // VERT; |
---|
1574 | @JetId = x(1)^3*x(2) + x(2)^(3*@k+1); |
---|
1575 | @fk = jet(@f, 3*@k+1, weight(@JetId)); |
---|
1576 | // "fuer k>1: f=", Show(@a); |
---|
1577 | // "fuer k>1: jet=", Show(jet(@fk, 4)); |
---|
1578 | } |
---|
1579 | |
---|
1580 | // @JetId = x(1)^3*x(2) + x(2)^(3*@k+1); |
---|
1581 | // @fk = jet(@f, 3*@k+1, weight(@JetId)); |
---|
1582 | // "Coeff von x3=",Coeff(@fk, x(1), x(1)^3); |
---|
1583 | // "Coeff von y3=",Coeff(@fk, x(2), x(2)^3); |
---|
1584 | // "f =", Show(@f); |
---|
1585 | // "k=", @k; |
---|
1586 | // "jet=", Show(jet(@fk, 4)); |
---|
1587 | return(@f); |
---|
1588 | |
---|
1589 | } |
---|
1590 | |
---|
1591 | //============================================================================= |
---|
1592 | // Id: Ausgaben.lib,v 1.17 1997/08/13 07:39:04 krueger Exp |
---|
1593 | /============================================================================= |
---|
1594 | // |
---|
1595 | // Please send bugs and comments to krueger@mathematik.uni-kl.de |
---|
1596 | // |
---|
1597 | //============================================================================= |
---|
1598 | // required libraries |
---|
1599 | |
---|
1600 | //============================================================================= |
---|
1601 | // required by |
---|
1602 | // LIB "Classify.lib" |
---|
1603 | // LIB "Kclass.lib" |
---|
1604 | |
---|
1605 | //========================================================================= |
---|
1606 | proc Ausgaben_lib |
---|
1607 | { |
---|
1608 | " |
---|
1609 | Funktion2(poly f,int k); (for internal use only) |
---|
1610 | Funktion4(poly f,int k); (for internal use only) |
---|
1611 | Funktion5(poly f,int k); (for internal use only) |
---|
1612 | Funktion7(poly f,int k); (for internal use only) |
---|
1613 | Funktion8(poly f,int k); (for internal use only) |
---|
1614 | Funktion9(poly f,int k); (for internal use only) |
---|
1615 | Funktion11(poly f,int k); (for internal use only) |
---|
1616 | Funktion12(poly f,int k); (for internal use only) |
---|
1617 | Funktion14(poly f,int k); (for internal use only) |
---|
1618 | Funktion15(poly f,int k); (for internal use only) |
---|
1619 | Funktion16(poly f,int k); (for internal use only) |
---|
1620 | Funktion19(poly f,int k); (for internal use only) |
---|
1621 | Funktion20(poly f,int k); (for internal use only) |
---|
1622 | Funktion21(poly f,int k); (for internal use only) |
---|
1623 | Funktion23(poly f,int k); (for internal use only) |
---|
1624 | Funktion24(poly f,int k); (for internal use only) |
---|
1625 | Funktion27(poly f,int k); (for internal use only) |
---|
1626 | Funktion28(poly f,int k); (for internal use only) |
---|
1627 | Funktion30(poly f,int k); (for internal use only) |
---|
1628 | Funktion31(poly f,int k); (for internal use only) |
---|
1629 | Funktion32(poly f,int k); (for internal use only) |
---|
1630 | Funktion34(poly f,int k); (for internal use only) |
---|
1631 | Funktion35(poly f,int k); (for internal use only) |
---|
1632 | Funktion37(poly f,int k); (for internal use only) |
---|
1633 | Funktion38(poly f,int k); (for internal use only) |
---|
1634 | Funktion39(poly f,int k); (for internal use only) |
---|
1635 | Funktion42(poly f,int k); (for internal use only) |
---|
1636 | Funktion43(poly f,int k); (for internal use only) |
---|
1637 | Funktion44(poly f,int k); (for internal use only) |
---|
1638 | Funktion45(poly f,int k); (for internal use only) |
---|
1639 | Funktion47(poly f,int k); (for internal use only) |
---|
1640 | Funktion60(poly f,int k); (for internal use only) |
---|
1641 | Funktion61(poly f,int k); (for internal use only) |
---|
1642 | Funktion62(poly f,int k); (for internal use only) |
---|
1643 | Funktion64(poly f,int k); (for internal use only) |
---|
1644 | Funktion65(poly f,int k); (for internal use only) |
---|
1645 | Funktion100(poly f,int k); (for internal use only) |
---|
1646 | Funktion101(poly f,int k); (for internal use only) |
---|
1647 | "; |
---|
1648 | } |
---|
1649 | |
---|
1650 | //============================================================================= |
---|
1651 | proc Funktion2 |
---|
1652 | USAGE: |
---|
1653 | { |
---|
1654 | poly @f = #[1]; |
---|
1655 | string @s = "The singularity `"+string(Show(@f)); |
---|
1656 | string @tp = "A["+string(Mu)+"]"; |
---|
1657 | |
---|
1658 | @s = @s +"' is R-equivalent to "+@tp+"."; |
---|
1659 | @s; // +" ("+SG_Typ+")"; |
---|
1660 | ring RingB=CharOfRing,x,ds; |
---|
1661 | // Morse(@f, Kbestimmt(@f)); |
---|
1662 | return(string(x^(Mu+1)), @tp); |
---|
1663 | } |
---|
1664 | //============================================================================= |
---|
1665 | proc Funktion4 |
---|
1666 | USAGE: |
---|
1667 | { |
---|
1668 | poly @f = #[1]; |
---|
1669 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1670 | string @tp = "D[4]"; |
---|
1671 | |
---|
1672 | @s = @s +"' is R-equivalent to "+@tp+"."; |
---|
1673 | @s; // +" ("+SG_Typ+")"; |
---|
1674 | return(Show(@f), @tp); |
---|
1675 | } |
---|
1676 | //============================================================================= |
---|
1677 | proc Funktion5 |
---|
1678 | USAGE: |
---|
1679 | { |
---|
1680 | poly @f = #[1]; |
---|
1681 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1682 | string @tp = "D["+string(Mu)+"]"; |
---|
1683 | |
---|
1684 | @s = @s +"' is R-equivalent to "+@tp+"."; |
---|
1685 | @s; // +" ("+SG_Typ+")"; |
---|
1686 | return(Show(@f), @tp); |
---|
1687 | } |
---|
1688 | //============================================================================= |
---|
1689 | proc Funktion7 |
---|
1690 | USAGE: |
---|
1691 | { |
---|
1692 | poly @f = #[1]; |
---|
1693 | int @k = #[2]; |
---|
1694 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1695 | string @tp = "E["+string(6*@k)+"]"; |
---|
1696 | |
---|
1697 | @s = @s + "' is R-equivalent to "+@tp + ", mu="+string(Mu)+", m="+string(@k-1); |
---|
1698 | if(6*@k != Mu) { "Fehler!!!"; } |
---|
1699 | @s; // +" ("+SG_Typ+")"; |
---|
1700 | return(Show(@f), @tp); |
---|
1701 | } |
---|
1702 | //============================================================================= |
---|
1703 | proc Funktion8 |
---|
1704 | USAGE: |
---|
1705 | { |
---|
1706 | poly @f = #[1]; |
---|
1707 | int @k = #[2]; |
---|
1708 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1709 | string @tp = "E["+string(6*@k+1)+"]"; |
---|
1710 | |
---|
1711 | @s = @s + "' is R-equivalent to "+@tp + ", mu="+string(Mu)+", m="+string(@k-1); |
---|
1712 | if( (6*@k+1) != Mu) { "Fehler!!!"; } |
---|
1713 | @s; // +" ("+SG_Typ+")"; |
---|
1714 | return(Show(@f), @tp); |
---|
1715 | } |
---|
1716 | //============================================================================= |
---|
1717 | proc Funktion9 |
---|
1718 | USAGE: |
---|
1719 | { |
---|
1720 | poly @f = #[1]; |
---|
1721 | int @k = #[2]; |
---|
1722 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1723 | string @tp = "E["+string(6*@k+2)+"]"; |
---|
1724 | |
---|
1725 | @s = @s + "' is R-equivalent to "+@tp + ", mu="+string(Mu)+", m="+string(@k-1); |
---|
1726 | if( (6*@k+2) != Mu) { "Fehler!!!"; } |
---|
1727 | @s; // +" ("+SG_Typ+")"; |
---|
1728 | return(Show(@f), @tp); |
---|
1729 | } |
---|
1730 | //============================================================================= |
---|
1731 | proc Funktion11 |
---|
1732 | USAGE: |
---|
1733 | { |
---|
1734 | poly @f = #[1]; |
---|
1735 | int @k = #[2]; |
---|
1736 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1737 | string @tp = "J["+string(@k)+",0]"; |
---|
1738 | |
---|
1739 | @s = @s + "' is R-equivalent to "+@tp + ", mu="+string(Mu)+", m="+string(@k-1); |
---|
1740 | if( (6*@k-2) != Mu) { "Fehler!!!"; } |
---|
1741 | @s; // +" ("+SG_Typ+")"; |
---|
1742 | return(Show(@f), @tp); |
---|
1743 | } |
---|
1744 | //============================================================================= |
---|
1745 | proc Funktion12 |
---|
1746 | USAGE: |
---|
1747 | { |
---|
1748 | poly @f = #[1]; |
---|
1749 | int @k = #[2]; |
---|
1750 | int @p = Mu - 6*@k +2; |
---|
1751 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1752 | string @tp = "J["+string(@k)+","+string(@p),"]"; |
---|
1753 | |
---|
1754 | @s = @s + "' is R-equivalent to "+@tp + ", mu="+string(Mu) + ", m="+string(@k-1); |
---|
1755 | if( (6*@k-2+@p) != Mu) { "Fehler!!!"; } |
---|
1756 | @s; // +" ("+SG_Typ+")"; |
---|
1757 | return(Show(@f), @tp); |
---|
1758 | } |
---|
1759 | //============================================================================= |
---|
1760 | proc Funktion14 |
---|
1761 | USAGE: |
---|
1762 | { |
---|
1763 | poly @f = #[1]; |
---|
1764 | string @s; |
---|
1765 | @s = "The singularity `"+Show(jet(@f, K)); |
---|
1766 | string @tp = "T[2,4,4]"; |
---|
1767 | |
---|
1768 | @s = @s +"' is R-equivalent to X[9] = X[1,0] = "+@tp + "., mu="+string(Mu); |
---|
1769 | @s; // +" ("+SG_Typ+")"; |
---|
1770 | return(Show(@f), @tp); |
---|
1771 | } |
---|
1772 | //============================================================================= |
---|
1773 | proc Funktion15 |
---|
1774 | USAGE: |
---|
1775 | { |
---|
1776 | poly @f = #[1]; |
---|
1777 | string @s; |
---|
1778 | int @p = Mu - 9; |
---|
1779 | @s = "The singularity `"+Show(jet(@f, K)); |
---|
1780 | string @tp = "T[2,4," + string(4+@p) + "]"; |
---|
1781 | |
---|
1782 | @s = @s+"' is R-equivalent to X[1,"+string(@p)+"] = "+@tp+"., mu="+string(Mu); |
---|
1783 | @s; // +" ("+SG_Typ+")"; |
---|
1784 | return(Show(@f), @tp); |
---|
1785 | } |
---|
1786 | //============================================================================= |
---|
1787 | proc Funktion16 |
---|
1788 | USAGE: |
---|
1789 | { |
---|
1790 | poly @f = #[1]; |
---|
1791 | string @s; |
---|
1792 | int @p; |
---|
1793 | int @q; |
---|
1794 | string @tp = "T[2,"+string(4+@p)+","+string(4+@q)+"]"; |
---|
1795 | |
---|
1796 | @s = "The singularity `"+Show(jet(@f, K)); |
---|
1797 | @s = @s +"' is R-equivalent to Y[1,"+string(@p)+","+string(@q)+"]"; |
---|
1798 | @s =@s+" = "+@tp+".p=??,q=??, mu="+string(Mu); |
---|
1799 | @s; // +" ("+SG_Typ+")"; |
---|
1800 | return(Show(@f), @tp); |
---|
1801 | } |
---|
1802 | //============================================================================= |
---|
1803 | proc Funktion19 |
---|
1804 | USAGE: |
---|
1805 | { |
---|
1806 | poly @f = #[1]; |
---|
1807 | int @p = #[2]; |
---|
1808 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1809 | string @tp = "Z["+string(6*@p+5)+"]"; |
---|
1810 | |
---|
1811 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(@p-1); |
---|
1812 | @s; // +" ("+SG_Typ+")"; |
---|
1813 | return(Show(@f), @tp); |
---|
1814 | } |
---|
1815 | //============================================================================= |
---|
1816 | proc Funktion20 |
---|
1817 | USAGE: |
---|
1818 | { |
---|
1819 | poly @f = #[1]; |
---|
1820 | int @p = #[2]; |
---|
1821 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1822 | string @tp = "Z["+string(6*@p+6)+"]"; |
---|
1823 | |
---|
1824 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(@p-1); |
---|
1825 | @s; // +" ("+SG_Typ+")"; |
---|
1826 | return(Show(@f), @tp); |
---|
1827 | } |
---|
1828 | //============================================================================= |
---|
1829 | proc Funktion21 |
---|
1830 | USAGE: |
---|
1831 | { |
---|
1832 | poly @f = #[1]; |
---|
1833 | int @p = #[2]; |
---|
1834 | string @s = "The singularity `"+Show(jet(@f,K)); |
---|
1835 | string @tp = "Z["+string(6*@p+7)+"]"; |
---|
1836 | |
---|
1837 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(@p-1); |
---|
1838 | @s; // +" ("+SG_Typ+")"; |
---|
1839 | return(Show(@f), @tp); |
---|
1840 | } |
---|
1841 | //============================================================================= |
---|
1842 | proc Funktion23 |
---|
1843 | USAGE: |
---|
1844 | { |
---|
1845 | poly @f = #[1]; |
---|
1846 | int @p = #[2]; |
---|
1847 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1848 | string @tp = "Z["+string(@p-1)+",0]"; |
---|
1849 | |
---|
1850 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(@p-1); |
---|
1851 | @s; // +" ("+SG_Typ+")"; |
---|
1852 | return(Show(@f), @tp); |
---|
1853 | } |
---|
1854 | //============================================================================= |
---|
1855 | proc Funktion24 |
---|
1856 | USAGE: |
---|
1857 | { |
---|
1858 | poly @f = #[1]; |
---|
1859 | int @p = #[2]; |
---|
1860 | int @r = Mu - 15; |
---|
1861 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1862 | string @tp = "Z["+string(@p-1)+","+string(@r)+"]"; |
---|
1863 | |
---|
1864 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(@p-1); |
---|
1865 | @s; // +" ("+SG_Typ+")"; |
---|
1866 | return(Show(@f), @tp); |
---|
1867 | } |
---|
1868 | //============================================================================= |
---|
1869 | proc Funktion27 |
---|
1870 | USAGE: |
---|
1871 | { |
---|
1872 | poly @f = #[1]; |
---|
1873 | int @k = #[2]; |
---|
1874 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1875 | string @tp = "W["+string(12*@k)+"]"; |
---|
1876 | |
---|
1877 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(3*@k-2); |
---|
1878 | @s; // +" ("+SG_Typ+")"; |
---|
1879 | return(Show(@f), @tp); |
---|
1880 | } |
---|
1881 | //============================================================================= |
---|
1882 | proc Funktion28 |
---|
1883 | USAGE: |
---|
1884 | { |
---|
1885 | poly @f = #[1]; |
---|
1886 | int @k = #[2]; |
---|
1887 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1888 | string @tp = "W["+string(12*@k+1)+"]"; |
---|
1889 | |
---|
1890 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(3*@k-2); |
---|
1891 | @s; // +" ("+SG_Typ+")"; |
---|
1892 | return(Show(@f), @tp); |
---|
1893 | } |
---|
1894 | //============================================================================= |
---|
1895 | proc Funktion30 |
---|
1896 | USAGE: |
---|
1897 | { |
---|
1898 | poly @f = #[1]; |
---|
1899 | int @k = #[2]; |
---|
1900 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1901 | string @tp = "W["+string(@k)+",0]"; |
---|
1902 | |
---|
1903 | @s = @s + "' is R-equivalent to " + @tp+", mu="+string(Mu) + ", m="+string(3*@k-1); |
---|
1904 | @s; // +" ("+SG_Typ+")"; |
---|
1905 | return(Show(@f), @tp); |
---|
1906 | } |
---|
1907 | //============================================================================= |
---|
1908 | proc Funktion31 |
---|
1909 | USAGE: |
---|
1910 | { |
---|
1911 | poly @f = #[1]; |
---|
1912 | int @k = #[2]; |
---|
1913 | int @i = Mu - 12*@k - 3; |
---|
1914 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1915 | string @tp = "W["+string(@k)+","+string(@i)+"]"; |
---|
1916 | |
---|
1917 | @s = @s +"' is R-equivalent to "+@tp+"(F31), mu="+string(Mu)+", m="+string(3*@k-1); |
---|
1918 | @s; // +" ("+SG_Typ+")"; |
---|
1919 | return(Show(@f), @tp); |
---|
1920 | } |
---|
1921 | //============================================================================= |
---|
1922 | proc Funktion32 |
---|
1923 | USAGE: |
---|
1924 | { |
---|
1925 | poly @f = #[1]; |
---|
1926 | int @k = #[2]; |
---|
1927 | int @i = Mu - 12*@k - 2; |
---|
1928 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1929 | string @tp = "W#["+string(@k)+","+string(@i)+"]"; |
---|
1930 | |
---|
1931 | @s = @s +"' is R-equivalent to "+@tp+"(F32), mu="+string(Mu)+", m="+string(3*@k-1); |
---|
1932 | @s; // +" ("+SG_Typ+")"; |
---|
1933 | return(Show(@f), @tp); |
---|
1934 | } |
---|
1935 | //============================================================================= |
---|
1936 | proc Funktion34 |
---|
1937 | USAGE: |
---|
1938 | { |
---|
1939 | poly @f = #[1]; |
---|
1940 | int @k = #[2]; |
---|
1941 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1942 | string @tp = "W["+string(12*@k+5)+"]"; |
---|
1943 | |
---|
1944 | @s = @s +"' is R-equivalent to "+@tp+"(F34), mu="+string(Mu)+", m="+string(3*@k-1); |
---|
1945 | @s; // +" ("+SG_Typ+")"; |
---|
1946 | return(Show(@f), @tp); |
---|
1947 | } |
---|
1948 | //============================================================================= |
---|
1949 | proc Funktion35 |
---|
1950 | USAGE: |
---|
1951 | { |
---|
1952 | poly @f = #[1]; |
---|
1953 | int @k = #[2]; |
---|
1954 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1955 | string @tp = "W["+string(12*@k+6)+"]"; |
---|
1956 | |
---|
1957 | @s = @s + "'is R-equivalent to "+@tp+"(F35), mu="+string(Mu)+", m="+string(3*@k-1); |
---|
1958 | @s; // +" ("+SG_Typ+")"; |
---|
1959 | return(Show(@f), @tp); |
---|
1960 | } |
---|
1961 | //============================================================================= |
---|
1962 | proc Funktion37 |
---|
1963 | USAGE: |
---|
1964 | { |
---|
1965 | poly @f = #[1]; |
---|
1966 | int @k = #[2]; |
---|
1967 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1968 | string @tp = "X["+string(@k)+",0]"; |
---|
1969 | |
---|
1970 | @s = @s +"' is R-equivalent to "+@tp+"(F37), mu="+string(Mu)+", m="+string(@k-1); |
---|
1971 | @s; // +" ("+SG_Typ+")"; |
---|
1972 | return(Show(@f), @tp); |
---|
1973 | } |
---|
1974 | //============================================================================= |
---|
1975 | proc Funktion38 |
---|
1976 | USAGE: |
---|
1977 | { |
---|
1978 | poly @f = #[1]; |
---|
1979 | int @k = #[2]; |
---|
1980 | int @p = Mu - 12*@k + 3; |
---|
1981 | string @s = "The singularity `"+Show(jet(@f, K-1)); |
---|
1982 | string @tp = "X["+string(@k)+","+string(@p)+"]"; |
---|
1983 | |
---|
1984 | @s = @s +"' is R-equivalent to "+@tp+"(F38), mu="+string(Mu)+", m="+string(@k-1); |
---|
1985 | @s; // +" ("+SG_Typ+")"; |
---|
1986 | return(Show(@f), @tp); |
---|
1987 | } |
---|
1988 | //============================================================================= |
---|
1989 | proc Funktion39 |
---|
1990 | USAGE: |
---|
1991 | { |
---|
1992 | poly @f = #[1]; |
---|
1993 | int @k = #[2]; |
---|
1994 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
1995 | string @tp = "Y["+string(@k)+",r,s]"; |
---|
1996 | |
---|
1997 | @s = @s +"' is R-equivalent to "+@tp+"(F39), mu="+string(Mu)+", m="+string(@k-1); |
---|
1998 | @s; // +" ("+SG_Typ+")"; |
---|
1999 | return(Show(@f), @tp); |
---|
2000 | } |
---|
2001 | //============================================================================= |
---|
2002 | proc Funktion42 |
---|
2003 | USAGE: |
---|
2004 | { |
---|
2005 | poly @f = #[1]; |
---|
2006 | int @k = #[2]; |
---|
2007 | int @r = #[3]; |
---|
2008 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2009 | string @tp = "Z["+string(@k)+","+string(12*@k+6*@r-1)+"]"; |
---|
2010 | |
---|
2011 | @s = @s +"' is R-equivalent to "+@tp+"(F42), mu="+string(Mu)+", m="+string(@k-1); |
---|
2012 | @s; // +" ("+SG_Typ+")"; |
---|
2013 | return(Show(@f), @tp); |
---|
2014 | } |
---|
2015 | //============================================================================= |
---|
2016 | proc Funktion43 |
---|
2017 | USAGE: |
---|
2018 | { |
---|
2019 | poly @f = #[1]; |
---|
2020 | int @k = #[2]; |
---|
2021 | int @r = #[3]; |
---|
2022 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2023 | string @tp = "Z["+string(@k)+","+string(12*@k+6*@r)+"]"; |
---|
2024 | |
---|
2025 | @s = @s +"' is R-equivalent to "+@tp+"(F43), mu="+string(Mu)+", m="+string(@k-1); |
---|
2026 | @s; // +" ("+SG_Typ+")"; |
---|
2027 | return(Show(@f), @tp); |
---|
2028 | } |
---|
2029 | //============================================================================= |
---|
2030 | proc Funktion44 |
---|
2031 | USAGE: |
---|
2032 | { |
---|
2033 | poly @f = #[1]; |
---|
2034 | int @k = #[2]; |
---|
2035 | int @r = #[3]; |
---|
2036 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2037 | string @tp = "Z["+string(@k)+","+string(12*@k+6*@r+1)+"]"; |
---|
2038 | |
---|
2039 | @s = @s +"' is R-equivalent to "+@tp+"(F44), mu="+string(Mu)+", m="+string(@k-1); |
---|
2040 | @s; // +" ("+SG_Typ+")"; |
---|
2041 | return(Show(@f), @tp); |
---|
2042 | } |
---|
2043 | //============================================================================= |
---|
2044 | proc Funktion45 |
---|
2045 | USAGE: |
---|
2046 | { |
---|
2047 | poly @f = #[1]; |
---|
2048 | int @k = #[2]; |
---|
2049 | int @r = #[3]; |
---|
2050 | int @S = #[4]; |
---|
2051 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2052 | string @tp = "Z["+string(@k)+","+string(@r)+","+string(@S)+"]"; |
---|
2053 | |
---|
2054 | @s = @s +"' is R-equivalent to "+@tp+"(F45/46), mu="+string(Mu)+", m="+string(@k-1); |
---|
2055 | @s; // +" ("+SG_Typ+")"; |
---|
2056 | return(Show(@f), @tp); |
---|
2057 | } |
---|
2058 | //============================================================================= |
---|
2059 | proc Funktion47 |
---|
2060 | USAGE: |
---|
2061 | { |
---|
2062 | poly @f = #[1]; |
---|
2063 | int @k = #[2]; |
---|
2064 | int @r = #[3]; |
---|
2065 | int @S = #[4]; |
---|
2066 | string @s = "The Singularity '";+Show(jet(@f, K)); |
---|
2067 | string @tp=""; |
---|
2068 | |
---|
2069 | @s = @s +"' has 4-jet equal to zero. (F47), mu="+string(Mu); |
---|
2070 | |
---|
2071 | @s; // +" ("+SG_Typ+")"; |
---|
2072 | return(Show(@f), @tp); |
---|
2073 | } |
---|
2074 | //============================================================================= |
---|
2075 | proc Funktion60 |
---|
2076 | USAGE: |
---|
2077 | { |
---|
2078 | poly @f = #[1]; |
---|
2079 | int @k = #[2]; |
---|
2080 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2081 | string @tp = "Q["+string(6*@k+4)+"]"; |
---|
2082 | |
---|
2083 | @s = @s +"' is R-equivalent to "+@tp+"(F60), mu="+string(Mu)+", m="+string(@k-1); |
---|
2084 | @s; // +" ("+SG_Typ+")"; |
---|
2085 | return(Show(@f), @tp); |
---|
2086 | } |
---|
2087 | //============================================================================= |
---|
2088 | proc Funktion61 |
---|
2089 | USAGE: |
---|
2090 | { |
---|
2091 | poly @f = #[1]; |
---|
2092 | int @k = #[2]; |
---|
2093 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2094 | string @tp = "Q["+string(6*@k+5)+"]"; |
---|
2095 | |
---|
2096 | @s = @s +"' is R-equivalent to "+@tp+"(F61), mu="+string(Mu)+", m="+string(@k-1); |
---|
2097 | @s; // +" ("+SG_Typ+")"; |
---|
2098 | return(Show(@f), @tp); |
---|
2099 | } |
---|
2100 | //============================================================================= |
---|
2101 | proc Funktion62 |
---|
2102 | USAGE: |
---|
2103 | { |
---|
2104 | poly @f = #[1]; |
---|
2105 | int @k = #[2]; |
---|
2106 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2107 | string @tp = "Q["+string(6*@k+6)+"]"; |
---|
2108 | |
---|
2109 | @s = @s +"' is R-equivalent to "+@tp+"(F62), mu="+string(Mu)+", m="+string(@k-1); |
---|
2110 | @s; // +" ("+SG_Typ+")"; |
---|
2111 | return(Show(@f), @tp); |
---|
2112 | } |
---|
2113 | //============================================================================= |
---|
2114 | proc Funktion64 |
---|
2115 | USAGE: |
---|
2116 | { |
---|
2117 | poly @f = #[1]; |
---|
2118 | int @k = #[2]; |
---|
2119 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2120 | string @tp = "Q["+string(@k)+",0]"; |
---|
2121 | |
---|
2122 | @s = @s +"' is R-equivalent to "+@tp+"(F64), mu="+string(Mu)+", m="+string(@k-1); |
---|
2123 | @s; // +" ("+SG_Typ+")"; |
---|
2124 | return(Show(@f), @tp); |
---|
2125 | } |
---|
2126 | //============================================================================= |
---|
2127 | proc Funktion65 |
---|
2128 | USAGE: |
---|
2129 | { |
---|
2130 | poly @f = #[1]; |
---|
2131 | int @k = #[2]; |
---|
2132 | int @i = Mu - (6*@k + 2); |
---|
2133 | string @s = "The singularity `"+Show(jet(@f, K)); |
---|
2134 | string @tp = "Q["+string(@k)+","+string(@i)+"]"; |
---|
2135 | |
---|
2136 | @s = @s +"' is R-equivalent to "+@tp+"(F65), mu="+string(Mu)+", m="+string(@k-1); |
---|
2137 | @s; // +" ("+SG_Typ+")"; |
---|
2138 | return(Show(@f), @tp); |
---|
2139 | } |
---|
2140 | //============================================================================= |
---|
2141 | proc Funktion84 |
---|
2142 | USAGE: |
---|
2143 | { |
---|
2144 | poly @f = #[1]; |
---|
2145 | int @k = #[2]; |
---|
2146 | " Schritt 84"; |
---|
2147 | |
---|
2148 | return(FunktionNoClass(#[1])); |
---|
2149 | } |
---|
2150 | //============================================================================= |
---|
2151 | proc Funktion86 |
---|
2152 | USAGE: |
---|
2153 | { |
---|
2154 | poly @f = #[1]; |
---|
2155 | int @k = #[2]; |
---|
2156 | " Schritt 86"; |
---|
2157 | |
---|
2158 | return(FunktionNoClass(#[1])); |
---|
2159 | } |
---|
2160 | //============================================================================= |
---|
2161 | proc Funktion87 |
---|
2162 | USAGE: |
---|
2163 | { |
---|
2164 | poly @f = #[1]; |
---|
2165 | int @k = #[2]; |
---|
2166 | " Schritt 87"; |
---|
2167 | |
---|
2168 | return(FunktionNoClass(#[1])); |
---|
2169 | } |
---|
2170 | //============================================================================= |
---|
2171 | proc Funktion89 |
---|
2172 | USAGE: |
---|
2173 | { |
---|
2174 | poly @f = #[1]; |
---|
2175 | int @k = #[2]; |
---|
2176 | " Schritt 89"; |
---|
2177 | |
---|
2178 | return(FunktionNoClass(#[1])); |
---|
2179 | } |
---|
2180 | //============================================================================= |
---|
2181 | proc Funktion100 |
---|
2182 | USAGE: |
---|
2183 | { |
---|
2184 | poly @f = #[1]; |
---|
2185 | int @k = #[2]; |
---|
2186 | string @s = "The Singularity '"+Show(jet(@f, K)); |
---|
2187 | string @tp = "V[1,"+string(Mu-15)+"]"; |
---|
2188 | |
---|
2189 | @s = @s +"' is R-equivalent to "+@tp+"(F100), mu="+string(Mu)+", m="+string(@k-1); |
---|
2190 | |
---|
2191 | @s; // +" ("+SG_Typ+")"; |
---|
2192 | return(Show(@f), @tp); |
---|
2193 | } |
---|
2194 | //============================================================================= |
---|
2195 | proc Funktion101 |
---|
2196 | USAGE: |
---|
2197 | { |
---|
2198 | poly @f = #[1]; |
---|
2199 | int @k = #[2]; |
---|
2200 | string @s = "The Singularity '"+Show(jet(@f, @k)); |
---|
2201 | string @tp = "V#[1,"+string(Mu-15)+"]"; |
---|
2202 | |
---|
2203 | @s = @s +"' is R-equivalent to "+@tp+"(F101), mu="+string(Mu)+", m="+string(@k-1); |
---|
2204 | |
---|
2205 | @s; // +" ("+SG_Typ+")"; |
---|
2206 | return(Show(@f), @tp); |
---|
2207 | } |
---|
2208 | //============================================================================= |
---|
2209 | // E n d O f F i l e |
---|