source: git/Singular/LIB/classify.lib @ 2b22b5c

spielwiese
Last change on this file since 2b22b5c was 2b22b5c, checked in by Kai Krüger <krueger@…>, 27 years ago
* Kclass.lib nach Classify.lib * loesche Kclass.lib git-svn-id: file:///usr/local/Singular/svn/trunk@623 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 65.5 KB
Line 
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
8LIBRARY:  Classify.lib
9
10 classify(f);            compute the Class of f.
11
12LIBRARY:  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
43LIB "Morse.lib";
44LIB "tools.lib";
45LIB "NFlist.lib";
46LIB "Hilbert.lib";
47
48//=============================================================================
49//=============================================================================
50// TopLevel Funktion of the Arnold-Classifier.
51//
52proc classify (poly @f_in)
53USAGE:    classify(f);  f=poly
54COMPUTE:  Normalform and singularity type of f
55RETURN:   Normalform of f
56EXAMPLE:  example classify; shows an example
57REMARK:   This version of classify is only alpha.
58          Please send bugs and comments to:
59          "Kai Krueger" <krueger@mathematik.uni-kl.de>
60NOTE:     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}
148example
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//=========================================================================
164proc 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//=============================================================================
197proc Klassifiziere (poly @f)
198USAGE:    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//=============================================================================
277proc Funktion1bis (poly @f, int corank)
278USAGE:    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//=============================================================================
328proc Funktion3 (poly @f, int corank);
329USAGE:    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
352proc Funktion6 (poly @f, int corank)
353USAGE:    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//=========================================================================
431proc Funktion13 (poly @f, int corank)
432USAGE:    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//=============================================================================
459proc Funktion17 (poly @f, int corank)
460USAGE:    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//=============================================================================
509proc Funktion25 (poly @f, int CoRang)
510USAGE:    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//=============================================================================
597proc Funktion40  (poly @f, int @k)
598USAGE:    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
690LIB "elim.lib";
691
692//=========================================================================
693proc Funktion50 (poly @f, int corank)
694USAGE:    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//=============================================================================
740proc Funktion51 (poly @f, int @k)
741USAGE:    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//=============================================================================
751proc Funktion52 (poly @f, int @k)
752USAGE:    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//=============================================================================
763proc Funktion54 (poly @f, int @k)
764USAGE:    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//=============================================================================
775proc Funktion56 (poly @f, int @k)
776USAGE:    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//=============================================================================
787proc Funktion58 (poly @fin, int @k)
788USAGE:    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//=============================================================================
960proc Funktion59 (poly @f, int @k)
961USAGE:    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//=============================================================================
1034proc Funktion66 (poly @f, int @k)
1035USAGE:    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//=============================================================================
1061proc Funktion82 (poly @f, int @k)
1062USAGE:    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    }
1104debug_log(2, VERT);
1105  }
1106//  else {
1107    map VERT=basering,x(@kx),x(@ky),x(@kz);
1108debug_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); }
1115debug_log(2,   "1)f??=", Show(@f3));
1116debug_log(2,   "1)f3=", Show(@f));
1117//------------------------------------------------------
1118debug_log(2,   size(coeffs(@f3, x(@kx))));
1119//  if (size(coeffs(@f3, x(@kx))) == 3) {
1120    matrix @C = coeffs(@f3, x(@kx));
1121debug_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
1128debug_log(2, @C);
1129debug_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//=============================================================================
1152proc Isomorphie_s82_z (poly @f, poly @fk, int @p)
1153USAGE:    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//=============================================================================
1176proc Isomorphie_s82_x (poly @f, poly @fk, int @p)
1177USAGE:    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//=============================================================================
1200proc Funktion83 (poly @f, int @k)
1201USAGE:    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) ;
1221debug_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) ;
1227debug_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);
1232debug_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) ;
1240debug_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);
1250debug_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//=============================================================================
1288proc Funktion97 (poly @f, int @K)
1289USAGE:    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//=============================================================================
1382proc Funktion103 (poly @f)
1383USAGE:    Funktion103();
1384{
1385  return(FunktionNoClass(@f,"3-jet = x3"));
1386}
1387//=============================================================================
1388proc Funktion104 (poly @f)
1389USAGE:    Funktion104();
1390{
1391  return(FunktionNoClass(@f));
1392}
1393//=============================================================================
1394proc Funktion105 (poly @f);
1395USAGE:    Funktion105();
1396{
1397  return(FunktionNoClass(@f));
1398}
1399//=============================================================================
1400proc FunktionNoClass (poly @f, list #)
1401USAGE:    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//=============================================================================
1415proc Tschirnhaus (poly @f, poly @x)
1416USAGE:    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//=============================================================================
1444proc Isomorphie_s17 (poly @f, poly @fk, int @k, int @ct)
1445USAGE:    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//=========================================================================
1606proc 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//=============================================================================
1651proc Funktion2
1652USAGE:   
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//=============================================================================
1665proc Funktion4
1666USAGE:   
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//=============================================================================
1677proc Funktion5
1678USAGE:   
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//=============================================================================
1689proc Funktion7
1690USAGE:   
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//=============================================================================
1703proc Funktion8
1704USAGE:   
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//=============================================================================
1717proc Funktion9
1718USAGE:   
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//=============================================================================
1731proc Funktion11
1732USAGE:   
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//=============================================================================
1745proc Funktion12
1746USAGE:   
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//=============================================================================
1760proc Funktion14
1761USAGE:   
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//=============================================================================
1773proc Funktion15
1774USAGE:   
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//=============================================================================
1787proc Funktion16
1788USAGE:   
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//=============================================================================
1803proc Funktion19
1804USAGE:   
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//=============================================================================
1816proc Funktion20
1817USAGE:   
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//=============================================================================
1829proc Funktion21
1830USAGE:   
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//=============================================================================
1842proc Funktion23
1843USAGE:   
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//=============================================================================
1855proc Funktion24
1856USAGE:   
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//=============================================================================
1869proc Funktion27
1870USAGE:   
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//=============================================================================
1882proc Funktion28
1883USAGE:   
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//=============================================================================
1895proc Funktion30
1896USAGE:   
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//=============================================================================
1908proc Funktion31
1909USAGE:   
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//=============================================================================
1922proc Funktion32
1923USAGE:   
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//=============================================================================
1936proc Funktion34
1937USAGE:   
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//=============================================================================
1949proc Funktion35
1950USAGE:   
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//=============================================================================
1962proc Funktion37
1963USAGE:   
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//=============================================================================
1975proc Funktion38
1976USAGE:   
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//=============================================================================
1989proc Funktion39
1990USAGE:   
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//=============================================================================
2002proc Funktion42
2003USAGE:   
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//=============================================================================
2016proc Funktion43
2017USAGE:   
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//=============================================================================
2030proc Funktion44
2031USAGE:   
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//=============================================================================
2044proc Funktion45
2045USAGE:   
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//=============================================================================
2059proc Funktion47
2060USAGE:   
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//=============================================================================
2075proc Funktion60
2076USAGE:   
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//=============================================================================
2088proc Funktion61
2089USAGE:   
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//=============================================================================
2101proc Funktion62
2102USAGE:   
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//=============================================================================
2114proc Funktion64
2115USAGE:   
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//=============================================================================
2127proc Funktion65
2128USAGE:   
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//=============================================================================
2141proc Funktion84
2142USAGE:   
2143{
2144  poly @f = #[1];
2145  int @k = #[2];
2146  "      Schritt 84";
2147
2148  return(FunktionNoClass(#[1]));
2149}
2150//=============================================================================
2151proc Funktion86
2152USAGE:   
2153{
2154  poly @f = #[1];
2155  int @k = #[2];
2156  "      Schritt 86";
2157
2158  return(FunktionNoClass(#[1]));
2159}
2160//=============================================================================
2161proc Funktion87
2162USAGE:   
2163{
2164  poly @f = #[1];
2165  int @k = #[2];
2166  "      Schritt 87";
2167
2168  return(FunktionNoClass(#[1]));
2169}
2170//=============================================================================
2171proc Funktion89
2172USAGE:   
2173{
2174  poly @f = #[1];
2175  int @k = #[2];
2176  "      Schritt 89";
2177
2178  return(FunktionNoClass(#[1]));
2179}
2180//=============================================================================
2181proc Funktion100
2182USAGE:   
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//=============================================================================
2195proc Funktion101
2196USAGE:   
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
Note: See TracBrowser for help on using the repository browser.