Changeset 2b22b5c in git for Singular/LIB/classify.lib


Ignore:
Timestamp:
Aug 15, 1997, 9:34:55 AM (27 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
b9cc2586d1d2d2e876a25e4ac83ffcb52f85a62f
Parents:
f988c941611227e28c070493ca12772f99b9d1e7
Message:
* Kclass.lib nach Classify.lib
* loesche Kclass.lib


git-svn-id: file:///usr/local/Singular/svn/trunk@623 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/classify.lib

    rf988c9 r2b22b5c  
    1 // $Id: classify.lib,v 1.10 1997-08-14 10:31:14 krueger Exp $
     1// $Id: classify.lib,v 1.11 1997-08-15 07:34:55 krueger Exp $
    22//=============================================================================
    33//
    … …  
    1010 classify(f);            compute the Class of f.
    1111
     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
    1241// required libraries
    1342
    1443LIB "Morse.lib";
    1544LIB "tools.lib";
    16 LIB "Kclass.lib";
    17 LIB "Ausgaben.lib";
    18 LIB "HKclass.lib";
    1945LIB "NFlist.lib";
    2046LIB "Hilbert.lib";
    … …  
    127153   poly g=classify(f);
    128154}
     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//=============================================================================
    1292209// E n d   O f   F i l e
Note: See TracChangeset for help on using the changeset viewer.