Changeset 45251f2 in git


Ignore:
Timestamp:
Sep 29, 1997, 1:30:33 PM (27 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')
Children:
b9fbf14a29ff5537d7f2de51a649d65742a21e1a
Parents:
7a30b9dc3c4269b1a18643775500a7f61dbfeeaa
Message:
Modified Files:
	classify.lib morse.lib nflist.lib
Added Files:
	tools.lib
Teil 2 der Aenderungen von GMG

----------------------------------------------------------------------


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/classify.lib

    r7a30b9 r45251f2  
    1 // $Id: classify.lib,v 1.13 1997-09-26 08:14:35 krueger Exp $
     1// $Id: classify.lib,v 1.14 1997-09-29 11:30:33 krueger Exp $
    22//
    33//  A library for the classification of isolated hypersurface singularities
    … …  
    3434LIB "nflist.lib";
    3535LIB "hilbert.lib";
    36 
    37 ///////////////////////////////////////////////////////////////////////////////
    38 //--------------------------- output ------------------------------------------
    39 ///////////////////////////////////////////////////////////////////////////////
    40 //=============================================================================
    41 // TopLevel Funktion of the Arnold-Classifier.
    42 //
     36LIB "elim.lib";
     37
     38///////////////////////////////////////////////////////////////////////////////
    4339proc classify (poly f_in)
    4440USAGE:    classify(f);  f=poly
    45 COMPUTE:  Normalform and singularity type of f
    46 RETURN:   Normalform of f
     41COMPUTE:  normal form and singularity type of f with respect to right
     42          equivalence, as given in the book "Singularities of differentiables
     43          maps, Volume I" by V.I. Arnold, S.M. Gusein-Zade, A.N. Varchenko
     44RETURN:   normal form of f, of type poly
     45REMARK:   This version of classify is only alpha. Please send bugs and comments
     46          to: "Kai Krueger" <krueger@mathematik.uni-kl.de>
     47          Be shure to have at least Singular version 0.9.3, better 1.0.1
     48NOTE:     type init_debug(n); (0 <= n <= 10) in order to get intermediate
     49          information, higher values of n give more information.
     50          The proc creates several global objects with names all starting with
     51          @, hence there should be no name conflicts
    4752EXAMPLE:  example classify; shows an example
    48 REMARK:   This version of classify is only alpha.
    49           Please send bugs and comments to:
    50           "Kai Krueger" <krueger@mathematik.uni-kl.de>
    51 NOTE:     The procedure init_debug(n); is usefull as trace-mode.
    52           n may range from 0 to 10, higher values of n give more information.
    53 {
    54 //         or set the shell-variable SG_DEBUG to the debugging level.
    55   if(system("version")<922) {
    56     "Sorry. You need to have at least Singular version 0.9.2.c"
    57     return;
    58   }
    59 
    60   def ring_top=basering;
    61   // Get characteristics of ring set it as default.
    62   if(defined(CharOfRing) == 1) { kill CharOfRing; }
    63   int CharOfRing = char(basering);
    64   export CharOfRing;
     53
     54{
     55//---------------------------- initialisation ---------------------------------
     56  init_debug();                    // initialize trace/debug mode
     57  int n        = nvars(basering);
     58  def ring_top = basering;
     59  int show_nf  = 1;                // return normal form if set to '1'
     60  int i;
    6561
    6662  if(checkring()) { return(f_in); }
    67   int @show_nf = 1;    // return normal form if set to '1'
    68 
    69   int @n = nvars(basering);
    70 
    71   // Save the name of initial ring
    72   int @i;
    73 
    74   // if trace/debug mode not set, do it!
    75   init_debug();
    7663
    7764  // define new ring
    78   if( defined(Rtop) == 1) { kill Rtop; }
    79   ring Rtop=char(basering),(x(1..@n)),(c,ds);
    80   export Rtop;
    81 
    82   map @Conv=ring_top,maxideal(1);
     65  if( defined(@Rtop) == 1) { kill @Rtop; }
     66  ring @Rtop=char(basering),(x(1..n)),(c,ds);
     67  export @Rtop;
     68
     69  map conv_ringtop2rtop=ring_top,maxideal(1);
    8370  setring ring_top;
    8471
    85   if(defined(ShowPoly) == 1) { kill ShowPoly; }
    86   map ShowPoly=Rtop,maxideal(1);
    87   export ShowPoly;
    88   setring Rtop;
     72  if(defined(@showpoly) == 1) { kill @showpoly; }
     73  map @showpoly=@Rtop,maxideal(1);
     74  export @showpoly;
     75  setring @Rtop;
    8976  init();
    9077
    91   string RingDisplay = "ring_top";
    92   export RingDisplay;
    93 
    94   string @s1;
    95   string @s2;
    96   string @s4;
    97   @s1,@s2=Klassifiziere(@Conv(f_in));
    98   // @s1: f nach saemtlichen Koordinatentransformationen
    99   // @s2: Typ des Polynoms f z.b: E[18]
    100   @s4 = "poly @f_out="+@s1+";";
    101   debug_log(10, "S1=", @s1);
    102   debug_log(10, "S2=", @s2);
    103 
    104   if( @s2[1,2]=="f " || @s2[1,4]=="The " || @s2=="Fehler!" || @s2=="A[0]") {
    105     if( @s2 != "Fehler!") { @s2; }
    106     if(@s1=="1" || @s2[1,4]=="The " || @s2=="Fehler!" ) {
     78  string @ringdisplay = "ring_top";
     79  export @ringdisplay;
     80
     81  string s1;
     82  string s2;
     83  string s4;
     84  s1,s2=Klassifiziere(conv_ringtop2rtop(f_in));
     85  // s1: f nach saemtlichen Koordinatentransformationen
     86  // s2: Typ des Polynoms f z.b: E[18]
     87  s4 = "poly f_out="+s1+";";
     88  debug_log(10, "S1=", s1);
     89  debug_log(10, "S2=", s2);
     90
     91  if( s2[1,2]=="f " || s2[1,4]=="The " || s2=="Fehler!" || s2=="A[0]") {
     92    if( s2 != "Fehler!") { s2; }
     93    if(s1=="1" || s2[1,4]=="The " || s2=="Fehler!" ) {
    10794      setring ring_top;
    10895      return(f_in);
    10996    }
    110     setring Rtop;
    111     execute @s4;
    112     map @ConvUp=Rtop,maxideal(1);
     97    setring @Rtop;
     98    execute s4;
     99    map ConvUp=@Rtop,maxideal(1);
    113100  }
    114101  else {
    115102    setring RingB;
    116     execute @s4;
    117     setring Rtop;
    118     map @ConvUp=RingB,maxideal(1);
    119   }
    120   if(@show_nf==1) {
    121     poly @f_nf = normalform(@s2);
    122     for(@i=4;@i<=@n;@i=@i+1) {
    123       @f_nf = @f_nf + x(@i)^2;
    124     }
    125     if(DeBug>1) { "Normal form NF(f)=", @f_nf; }
    126   }
    127   poly @f_out = @ConvUp(@f_out);
    128   for(@i=CoRang+1;@i<=@n;@i=@i+1) {
    129     @f_out = @f_out + x(@i)^2;
     103    execute s4;
     104    setring @Rtop;
     105    map ConvUp=RingB,maxideal(1);
     106  }
     107  if(show_nf==1) {
     108    poly f_nf = normalform(s2);
     109    for(i=4;i<=n;i=i+1) {
     110      f_nf = f_nf + x(i)^2;
     111    }
     112    if(DeBug>1) { "Normal form NF(f)=", f_nf; }
     113  }
     114  poly f_out = ConvUp(f_out);
     115  for(i=CoRang+1;i<=n;i=i+1) {
     116    f_out = f_out + x(i)^2;
    130117  }
    131118  setring ring_top;
    132   map @ConvBack=Rtop,maxideal(1);
    133 
    134   if(@show_nf == 1) {
    135     return(@ConvBack(@f_nf));
    136   }
    137   else { return(@ConvBack(@f_out)); }
     119  map conv_rtop2ringtop=@Rtop,maxideal(1);
     120
     121  if(show_nf == 1) {
     122    return(conv_rtop2ringtop(f_nf));
     123  }
     124  else { return(conv_rtop2ringtop(f_out)); }
    138125}
    139126example
    140127{"EXAMPLE"; echo=2;
    141128   ring r=0,(x,y,z),ds;
    142    init_debug(2);
    143129   poly f=(x2+3y-2z)^2+xyz-(x-y3+x2*z3)^3;
    144    poly g=classify(f);
    145 }
    146 //=============================================================================
    147 // Id: Kclass.lib,v 1.12 1997/08/13 17:21:05 krueger Exp
    148 //=============================================================================
    149 proc Klassifiziere (poly @f)
    150 USAGE:    Klassifiziere(f);
    151 {
    152   string @s1;
    153   int @cnt;
    154 // Warum hier init() noch einmal, keine Ahnung.
    155 // Wenn nicht geht's einfach nicht. Hans fragen!
    156   init(1);
    157   int  @n = nvars(basering);    // Zahl der Variablen des aktuellen Rings.
    158 
    159   // Define always 'RingDisplay' to be able to run 'Show(f)'
    160   if( defined(RingDisplay) == 0) {
    161     string RingDisplay;
    162     export RingDisplay;
    163   }
    164   RingDisplay = "setring RingB;";
    165 
    166   if(defined(SG_Typ) == 1) { kill SG_Typ; } // Typ(s) von f nach Hilbert.
    167   string SG_Typ = "";
    168   export SG_Typ;
    169 
    170   //
    171   @s1 = "ring RingB="+string(CharOfRing)+",("+A_Z("x", @n)+"),ds;";
    172   execute @s1;                  // in diesem Ring werden Polynome angezeigt.
    173   @s1 = "map ShowPoly=Rtop,"+A_Z("x", @n)+";";
    174   execute @s1;                  // Hiermit werden Polynome angezeigt.
    175   export ShowPoly;
    176   setring Rtop;                 // in den Ausgangs-ring zurueck.
    177   export RingB;
    178 
    179   //===============================================
    180 
    181   if(jet(@f,0) != 0 ) {
    182     if(defined(CoRang) == 0) { int CoRang = CoRangf(@f); }
    183     return("1", "f is a unit");
    184   }
    185 
    186   debug_log(1, "Computing Basicinvariants of f ...");
    187   if(defined(Mu) == 1) { kill Mu; }
    188   if(defined(K) == 1) { kill K; }
    189   if(defined(CoRang) == 1) { kill CoRang; }
    190   int K;
    191   int Mu;
    192   int CoRang;
    193   K, Mu, CoRang = basicinvariants(@f);
    194   "About the singularity :";
    195   "          Milnor number(f)   = "+string(Mu);
    196   "          Corank(f)          = "+string(CoRang);
    197   "          Determinacy       <= "+string(K);
    198   export CoRang, K, Mu;
    199 
    200 //  ideal @Jf = Jf;
    201 //  if(dim(std(EH(@Jf))) != @n) { return("x(1)","A[0]"); }
    202   if( Mu == 0) {
    203     CoRang=1;
    204     return("x(1)","A[0]");
    205   }
    206 
    207   if(Mu<0) {
    208     "The Milnor number of the function is infinite.";
    209     "The singularity is not in Arnolds list.";
    210     return("", "Fehler!");
    211   }
    212 
    213   @f = jet(@f, K);
    214   @s1,@cnt = HKclass(Hilb(@f));
    215   if(@cnt>0) { "Guessing type via Hilbert polynomial: ", @s1; }
    216   else { "Hilbert polynomial not recognised. Milnor code = ", Hilb(@f); }
    217   "";
    218   "Computing normal form ...";
    219 
    220   // Einteilung nach Corang
    221   if( defined(ShowPhi) == 0) { int ShowPhi = 0; }
    222   if(CoRang == 0) { return(Funktion2(@f, CoRang)); }
    223   if(CoRang == 1) { return(Funktion2(@f, CoRang)); }
    224   if(CoRang == 2) { return(Funktion1bis(@f, CoRang)); }
    225   if(CoRang == 3) { return(Funktion1bis(@f, CoRang)); }
    226   return(Funktion105(@f, CoRang));
    227 }
    228 ///////////////////////////////////////////////////////////////////////////////
    229 proc Funktion1bis (poly @f, int corank)
    230 USAGE:    Funktion1bis();
    231 { // pruefe ob abspaltung von Quadraten noetig, wenn ja tue dies.
    232 
    233   int  @n = nvars(basering);
    234   string @s1;
    235   string @RestRing = nameof(basering);
    236 
    237   if( @n > corank) {
    238     "I have to apply the splitting lemma. This will take some time....:-)";
    239     poly @g = Morse(@f, K, corank);
    240 
    241     @g = ReOrder(@g);
    242     if(defined(PhiG)==1) { kill PhiG; }
    243     if(defined(Rrest) == 1) { kill Rrest; }
    244     if(defined(ShowPoly) == 1 ) { kill ShowPoly; }
    245     if(defined(RingB) == 1) { kill RingB; }
    246 
    247     execute Setring(corank, "Rrest");
    248     export Rrest;
    249     @RestRing = nameof(basering);
    250 
    251     map @MapReduce=Rtop,maxideal(1);
    252     poly @G = @MapReduce(@g);
    253 
    254     @s1 = "map PhiG=Rtop," + string(maxideal(1));// Konstruiere Id auf r
     130   classify(f);
     131   init_debug(3);
     132   classify(f);
     133}
     134
     135///////////////////////////////////////////////////////////////////////////////
     136  proc Klassifiziere (poly f)
     137  {
     138  //-------------------------- initialisation ---------------------------------
     139    string s1;
     140    int cnt;
     141  //  init(1);
     142    int  n = nvars(basering);    // Zahl der Variablen des aktuellen Rings.
     143
     144    // Define always '@ringdisplay' to be able to run 'Show(f)'
     145    if( defined(@ringdisplay) == 0) {
     146      string @ringdisplay;
     147      export @ringdisplay;
     148    }
     149    @ringdisplay = "setring RingB;";
     150
     151    if(defined(SG_Typ) == 1) { kill SG_Typ; } // Typ(s) von f nach Hilbert.
     152    string SG_Typ = "";
     153    export SG_Typ;
     154
     155    execute ("ring RingB="+charstr(basering)+",("+A_Z("x", n)+"),(c,ds);");
     156    execute("map @showpoly=@Rtop,"+A_Z("x", n)+";");
     157    export @showpoly;
     158    setring @Rtop;                 // in den Ausgangs-ring zurueck.
     159    export RingB;
     160
     161    //===============================================
     162
     163    if(jet(f,0) != 0 ) {
     164      if(defined(CoRang) == 0) { int CoRang = CoRangf(f); }
     165      return("1", "f is a unit");
     166    }
     167
     168    debug_log(1, "Computing Basicinvariants of f ...");
     169    if(defined(Mu) == 1) { kill Mu; }
     170    if(defined(K) == 1) { kill K; }
     171    if(defined(CoRang) == 1) { kill CoRang; }
     172    int K;
     173    int Mu;
     174    int CoRang;
     175    K, Mu, CoRang = basicinvariants(f);
     176    "About the singularity :";
     177    "          Milnor number(f)   = "+string(Mu);
     178    "          Corank(f)          = "+string(CoRang);
     179    "          Determinacy       <= "+string(K);
     180    export CoRang, K, Mu;
     181
     182  //  ideal Jf = Jf;
     183  //  if(dim(std(EH(Jf))) != n) { return("x(1)","A[0]"); }
     184    if( Mu == 0) {
     185      CoRang=1;
     186      return("x(1)","A[0]");
     187    }
     188
     189    if(Mu<0) {
     190      "The Milnor number of the function is infinite.";
     191      "The singularity is not in Arnolds list.";
     192      return("", "Fehler!");
     193    }
     194
     195    f = jet(f, K);
     196    s1,cnt = HKclass(Hilb(f));
     197    if(cnt>0) { "Guessing type via Hilbert polynomial: ", s1; }
     198    else { "Hilbert polynomial not recognised. Milnor code = ", Hilb(f); }
     199    "";
     200    "Computing normal form ...";
     201
     202    // Einteilung nach Corang
     203    if( defined(ShowPhi) == 0) { int ShowPhi = 0; }
     204    if(CoRang == 0) { return(Funktion2(f, CoRang)); }
     205    if(CoRang == 1) { return(Funktion2(f, CoRang)); }
     206    if(CoRang == 2) { return(Funktion1bis(f, CoRang)); }
     207    if(CoRang == 3) { return(Funktion1bis(f, CoRang)); }
     208    return(Funktion105(f, CoRang));
     209  }
     210
     211///////////////////////////////////////////////////////////////////////////////
     212  proc Funktion1bis (poly @f, int corank)
     213  { // pruefe ob abspaltung von Quadraten noetig, wenn ja tue dies.
     214 
     215    int  @n = nvars(basering);
     216    string @s1;
     217    string @RestRing = nameof(basering);
     218 
     219    if( @n > corank) {
     220      "I have to apply the splitting lemma. This will take some time....:-)";
     221      poly @g = Morse(@f, K, corank);
     222 
     223      @g = ReOrder(@g);
     224      if(defined(PhiG)==1) { kill PhiG; }
     225      if(defined(Rrest) == 1) { kill Rrest; }
     226      if(defined(@showpoly) == 1 ) { kill @showpoly; }
     227      if(defined(RingB) == 1) { kill RingB; }
     228 
     229      execute Setring(corank, "Rrest");
     230      export Rrest;
     231      @RestRing = nameof(basering);
     232 
     233      map @MapReduce=@Rtop,maxideal(1);
     234      poly @G = @MapReduce(@g);
     235 
     236      @s1 = "map PhiG=@Rtop," + string(maxideal(1));// Konstruiere Id auf r
     237      execute @s1;
     238      export PhiG;
     239 
     240      execute("ring RingB="+charstr(basering)+",("+A_Z("x", corank)+"),(c,ds);");
     241      export RingB;
     242    }
     243    else { poly @G = @f; }
     244 
     245    setring RingB;
     246    @s1 = "map @showpoly=",@RestRing,","+A_Z("x", corank)+";";
    255247    execute @s1;
    256     export PhiG;
    257 
    258     @s1 = "ring RingB=",string(CharOfRing),",("+A_Z("x", corank)+"),ds;";
     248    export @showpoly;
     249    @s1 = "setring ",@RestRing,";";
    259250    execute @s1;
    260     export RingB;
    261   }
    262   else { poly @G = @f; }
    263 
    264   setring RingB;
    265   @s1 = "map ShowPoly=",@RestRing,","+A_Z("x", corank)+";";
    266   execute @s1;
    267   export ShowPoly;
    268   @s1 = "setring ",@RestRing,";";
    269   execute @s1;
    270 
    271   if(defined(PhiG)==0) {
    272     map PhiG=basering, maxideal(1);
    273     export PhiG;
    274   }
    275   if(corank == 2) { return(Funktion3(@G, corank)); }
    276   if(corank == 3) { return(Funktion50(@G, corank)); }
    277   return("","Fehler!");
    278 }
     251 
     252    if(defined(PhiG)==0) {
     253      map PhiG=basering, maxideal(1);
     254      export PhiG;
     255    }
     256    if(corank == 2) { return(Funktion3(@G, corank)); }
     257    if(corank == 3) { return(Funktion50(@G, corank)); }
     258    return("","Fehler!");
     259  }
     260
    279261///////////////////////////////////////////////////////////////////////////////
    280262proc Funktion3 (poly @f, int corank);
    … …  
    300282  return("", "Fehler!");        // Should never occur
    301283}
    302 ///////////////////////////////////////////////////////////////////////////////
    303 //proc Funktion6 - put here
     284
     285///////////////////////////////////////////////////////////////////////////////
    304286proc Funktion6 (poly @f, int corank)
    305287USAGE:    Funktion6()
    … …  
    372354  return("","Fehler!");
    373355}
    374 ///////////////////////////////////////////////////////////////////////////////
    375 //proc Funktion13 - put here
    376 //=========================================================================
    377 // Id: lib_WorkOn,v 1.8 1995/01/27 12:53:11 krueger Exp
    378 //
    379 ///////////////////////////////////////////////////////////////////////////////
    380 //
    381 
    382 //=========================================================================
     356
     357///////////////////////////////////////////////////////////////////////////////
    383358proc Funktion13 (poly @f, int corank)
    384359USAGE:    Funktion13();
    … …  
    407382  return("","Fehler!");
    408383}
    409 ///////////////////////////////////////////////////////////////////////////////
     384
    410385///////////////////////////////////////////////////////////////////////////////
    411386proc Funktion17 (poly @f, int corank)
    … …  
    458433  return("","Fehler!");
    459434}
     435
    460436///////////////////////////////////////////////////////////////////////////////
    461437proc Funktion25 (poly @f, int CoRang)
    … …  
    546522  return("","Fehler!"):
    547523}
     524
    548525///////////////////////////////////////////////////////////////////////////////
    549526proc Funktion40  (poly @f, int @k)
    550527USAGE:    Funktion40();
    551528{
    552 //  poly @f = #[1];
    553 //  int @k = #[2];
    554529  int @r;
    555530  string @Typ;
    … …  
    630605 return("","Fehler!");
    631606}
    632 ///////////////////////////////////////////////////////////////////////////////
    633 ///////////////////////////////////////////////////////////////////////////////
    634 //proc Funktion50 - put here
    635 //=========================================================================
    636 // Id: lib_WorkOn,v 1.6 1995/08/29 18:04:09 krueger Exp
    637 //
    638 // Please send bugs and comments to krueger@mathematik.uni-kl.de
    639 //
    640 ///////////////////////////////////////////////////////////////////////////////
    641 
    642 LIB "elim.lib";
    643 
    644 //=========================================================================
     607
     608///////////////////////////////////////////////////////////////////////////////
    645609proc Funktion50 (poly @f, int corank)
    646610USAGE:    Funktion50();
    … …  
    689653  return("","Fehler!");
    690654}
     655
    691656///////////////////////////////////////////////////////////////////////////////
    692657proc Funktion51 (poly @f, int @k)
    … …  
    700665  return(Show(@f), @tp);
    701666}
     667
    702668///////////////////////////////////////////////////////////////////////////////
    703669proc Funktion52 (poly @f, int @k)
    … …  
    712678  return(Show(@f), @tp);
    713679}
     680
    714681///////////////////////////////////////////////////////////////////////////////
    715682proc Funktion54 (poly @f, int @k)
    … …  
    724691  return(Show(@f), @tp);
    725692}
     693
    726694///////////////////////////////////////////////////////////////////////////////
    727695proc Funktion56 (poly @f, int @k)
    … …  
    736704  return(Show(@f), @tp);
    737705}
     706
    738707///////////////////////////////////////////////////////////////////////////////
    739708proc Funktion58 (poly @fin, int @k)
    … …  
    1010979  "nach z:",Show(@fz), "  Id=", @JetId, "  Dim=", dim(@JetId);
    1011980}
     981
    1012982///////////////////////////////////////////////////////////////////////////////
    1013983proc Funktion82 (poly @f, int @k)
    … …  
    11011071  return("", "Fehler");
    11021072}
     1073
    11031074///////////////////////////////////////////////////////////////////////////////
    11041075proc Isomorphie_s82_z (poly @f, poly @fk, int @p)
    … …  
    11491120  return(@f);
    11501121}
     1122
    11511123///////////////////////////////////////////////////////////////////////////////
    11521124proc Funktion83 (poly @f, int @k)
    … …  
    13311303  return(Show(@f), "V[k,r]");
    13321304}
     1305
    13331306///////////////////////////////////////////////////////////////////////////////
    13341307proc Funktion103 (poly @f)
    … …  
    13371310  return(FunktionNoClass(@f,"3-jet = x3"));
    13381311}
     1312
    13391313///////////////////////////////////////////////////////////////////////////////
    13401314proc Funktion104 (poly @f)
    … …  
    13431317  return(FunktionNoClass(@f));
    13441318}
     1319
    13451320///////////////////////////////////////////////////////////////////////////////
    13461321proc Funktion105 (poly @f);
    … …  
    13491324  return(FunktionNoClass(@f));
    13501325}
     1326
    13511327///////////////////////////////////////////////////////////////////////////////
    13521328proc FunktionNoClass (poly @f, list #)
    13531329USAGE:    FunktionNoClass();
    1354 
    13551330{
    13561331  if(size(#)==2) { string @txt=#[2]; }
    … …  
    13631338  return(Show(@f), @s);
    13641339}
    1365 ///////////////////////////////////////////////////////////////////////////////
     1340
    13661341///////////////////////////////////////////////////////////////////////////////
    13671342proc tschirnhaus (poly @f, poly @x)
    … …  
    13921367  return(@Phi(@f), @Phi);
    13931368}
    1394 ///////////////////////////////////////////////////////////////////////////////
     1369
    13951370///////////////////////////////////////////////////////////////////////////////
    13961371proc Isomorphie_s17 (poly @f, poly @fk, int @k, int @ct)
    … …  
    15411516}
    15421517
    1543 //=============================================================================
    1544 //  Id: Ausgaben.lib,v 1.17 1997/08/13 07:39:04 krueger Exp
    1545 /=============================================================================
    1546 //
    1547 // Please send bugs and comments to krueger@mathematik.uni-kl.de
    1548 //
    1549 ///////////////////////////////////////////////////////////////////////////////
    1550 // required libraries
    1551 
    1552 ///////////////////////////////////////////////////////////////////////////////
    1553 // required by
    1554 // LIB "Classify.lib"
    1555 // LIB "Kclass.lib"
    1556 
    1557 ///////////////////////////////////////////////////////////////////////////////
    1558 proc Funktion2 (poly @f, int corank)
     1518///////////////////////////////////////////////////////////////////////////////
     1519proc Funktion2 (poly f, int corank)
    15591520USAGE:   
    15601521{
    1561   poly @f = #[1];
    1562   string @s = "The singularity `"+string(Show(@f));
    1563   string @tp = "A["+string(Mu)+"]";
    1564 
    1565   @s = @s +"' is R-equivalent to "+@tp+".";
    1566   @s; // +"  ("+SG_Typ+")";
    1567   ring RingB=CharOfRing,x,ds;
    1568 //  Morse(@f, Kbestimmt(@f));
    1569   return(string(x^(Mu+1)), @tp);
    1570 }
    1571 ///////////////////////////////////////////////////////////////////////////////
    1572 proc Funktion4
     1522  string s = "The singularity `"+string(Show(f));
     1523  string tp = "A["+string(Mu)+"]";
     1524
     1525  s = s +"' is R-equivalent to "+tp+".";
     1526  s; // +"  ("+SG_Typ+")";
     1527  ring RingB=char(basering),x,ds;
     1528//  Morse(f, Kbestimmt(f));
     1529  return(string(x^(Mu+1)), tp);
     1530}
     1531
     1532///////////////////////////////////////////////////////////////////////////////
     1533proc Funktion4 (poly f, int corank)
    15731534USAGE:   
    15741535{
    1575   poly @f = #[1];
    1576   string @s = "The singularity `"+Show(jet(@f, K));
    1577   string @tp = "D[4]";
    1578 
    1579   @s = @s +"' is R-equivalent to "+@tp+".";
    1580   @s; // +"  ("+SG_Typ+")";
    1581   return(Show(@f), @tp);
    1582 }
    1583 ///////////////////////////////////////////////////////////////////////////////
    1584 proc Funktion5
     1536  string s = "The singularity `"+Show(jet(f, K));
     1537  string tp = "D[4]";
     1538
     1539  s = s +"' is R-equivalent to "+tp+".";
     1540  s; // +"  ("+SG_Typ+")";
     1541  setring @Rtop;
     1542  return(Show(f), tp);
     1543//  return(f, tp);
     1544}
     1545
     1546///////////////////////////////////////////////////////////////////////////////
     1547proc Funktion5 (poly f, int corank)
    15851548USAGE:   
    15861549{
    1587   poly @f = #[1];
    1588   string @s = "The singularity `"+Show(jet(@f, K));
    1589   string @tp = "D["+string(Mu)+"]";
    1590 
    1591   @s = @s +"' is R-equivalent to "+@tp+".";
    1592   @s; // +"  ("+SG_Typ+")";
    1593   return(Show(@f), @tp);
    1594 }
     1550  string s = "The singularity `"+Show(jet(f, K));
     1551  string tp = "D["+string(Mu)+"]";
     1552
     1553  s = s +"' is R-equivalent to "+tp+".";
     1554  s; // +"  ("+SG_Typ+")";
     1555  return(Show(f), tp);
     1556}
     1557
    15951558///////////////////////////////////////////////////////////////////////////////
    15961559proc Funktion7
    … …  
    16071570  return(Show(@f), @tp);
    16081571}
     1572
    16091573///////////////////////////////////////////////////////////////////////////////
    16101574proc Funktion8
    … …  
    16211585  return(Show(@f), @tp);
    16221586}
     1587
    16231588///////////////////////////////////////////////////////////////////////////////
    16241589proc Funktion9
    … …  
    16351600  return(Show(@f), @tp);
    16361601}
     1602
    16371603///////////////////////////////////////////////////////////////////////////////
    16381604proc Funktion11
    … …  
    16491615  return(Show(@f), @tp);
    16501616}
     1617
    16511618///////////////////////////////////////////////////////////////////////////////
    16521619proc Funktion12
    … …  
    16641631  return(Show(@f), @tp);
    16651632}
     1633
    16661634///////////////////////////////////////////////////////////////////////////////
    16671635proc Funktion14
    … …  
    16771645  return(Show(@f), @tp);
    16781646}
     1647
    16791648///////////////////////////////////////////////////////////////////////////////
    16801649proc Funktion15
    … …  
    16911660  return(Show(@f), @tp);
    16921661}
     1662
    16931663///////////////////////////////////////////////////////////////////////////////
    16941664proc Funktion16
    … …  
    17071677  return(Show(@f), @tp);
    17081678}
     1679
    17091680///////////////////////////////////////////////////////////////////////////////
    17101681proc Funktion19
    … …  
    17201691  return(Show(@f), @tp);
    17211692}
     1693
    17221694///////////////////////////////////////////////////////////////////////////////
    17231695proc Funktion20
    … …  
    17331705  return(Show(@f), @tp);
    17341706}
     1707
    17351708///////////////////////////////////////////////////////////////////////////////
    17361709proc Funktion21
    … …  
    17461719  return(Show(@f), @tp);
    17471720}
     1721
    17481722///////////////////////////////////////////////////////////////////////////////
    17491723proc Funktion23
    … …  
    17591733  return(Show(@f), @tp);
    17601734}
     1735
    17611736///////////////////////////////////////////////////////////////////////////////
    17621737proc Funktion24
    … …  
    17731748  return(Show(@f), @tp);
    17741749}
     1750
    17751751///////////////////////////////////////////////////////////////////////////////
    17761752proc Funktion27
    … …  
    17861762  return(Show(@f), @tp);
    17871763}
     1764
    17881765///////////////////////////////////////////////////////////////////////////////
    17891766proc Funktion28
    … …  
    17991776  return(Show(@f), @tp);
    18001777}
     1778
    18011779///////////////////////////////////////////////////////////////////////////////
    18021780proc Funktion30
    … …  
    18121790  return(Show(@f), @tp);
    18131791}
     1792
    18141793///////////////////////////////////////////////////////////////////////////////
    18151794proc Funktion31
    … …  
    18261805  return(Show(@f), @tp);
    18271806}
     1807
    18281808///////////////////////////////////////////////////////////////////////////////
    18291809proc Funktion32
    … …  
    18401820  return(Show(@f), @tp);
    18411821}
     1822
    18421823///////////////////////////////////////////////////////////////////////////////
    18431824proc Funktion34
    … …  
    18531834  return(Show(@f), @tp);
    18541835}
     1836
    18551837///////////////////////////////////////////////////////////////////////////////
    18561838proc Funktion35
    … …  
    18661848  return(Show(@f), @tp);
    18671849}
     1850
    18681851///////////////////////////////////////////////////////////////////////////////
    18691852proc Funktion37
    … …  
    18791862  return(Show(@f), @tp);
    18801863}
     1864
    18811865///////////////////////////////////////////////////////////////////////////////
    18821866proc Funktion38
    … …  
    18931877  return(Show(@f), @tp);
    18941878}
     1879
    18951880///////////////////////////////////////////////////////////////////////////////
    18961881proc Funktion39
    … …  
    19061891  return(Show(@f), @tp);
    19071892}
     1893
    19081894///////////////////////////////////////////////////////////////////////////////
    19091895proc Funktion42
    … …  
    19201906  return(Show(@f), @tp);
    19211907}
     1908
    19221909///////////////////////////////////////////////////////////////////////////////
    19231910proc Funktion43
    … …  
    19341921  return(Show(@f), @tp);
    19351922}
     1923
    19361924///////////////////////////////////////////////////////////////////////////////
    19371925proc Funktion44
    … …  
    19481936  return(Show(@f), @tp);
    19491937}
     1938
    19501939///////////////////////////////////////////////////////////////////////////////
    19511940proc Funktion45
    … …  
    19631952  return(Show(@f), @tp);
    19641953}
     1954
    19651955///////////////////////////////////////////////////////////////////////////////
    19661956proc Funktion47
    … …  
    19791969  return(Show(@f), @tp);
    19801970}
     1971
    19811972///////////////////////////////////////////////////////////////////////////////
    19821973proc Funktion60
    … …  
    19921983  return(Show(@f), @tp);
    19931984}
     1985
    19941986///////////////////////////////////////////////////////////////////////////////
    19951987proc Funktion61
    … …  
    20051997  return(Show(@f), @tp);
    20061998}
     1999
    20072000///////////////////////////////////////////////////////////////////////////////
    20082001proc Funktion62
    … …  
    20182011  return(Show(@f), @tp);
    20192012}
     2013
    20202014///////////////////////////////////////////////////////////////////////////////
    20212015proc Funktion64
    … …  
    20312025  return(Show(@f), @tp);
    20322026}
     2027
    20332028///////////////////////////////////////////////////////////////////////////////
    20342029proc Funktion65
    … …  
    20452040  return(Show(@f), @tp);
    20462041}
     2042
    20472043///////////////////////////////////////////////////////////////////////////////
    20482044proc Funktion84
    … …  
    20552051  return(FunktionNoClass(#[1]));
    20562052}
     2053
    20572054///////////////////////////////////////////////////////////////////////////////
    20582055proc Funktion86
    … …  
    20652062  return(FunktionNoClass(#[1]));
    20662063}
     2064
    20672065///////////////////////////////////////////////////////////////////////////////
    20682066proc Funktion87
    … …  
    20752073  return(FunktionNoClass(#[1]));
    20762074}
     2075
    20772076///////////////////////////////////////////////////////////////////////////////
    20782077proc Funktion89
    … …  
    20852084  return(FunktionNoClass(#[1]));
    20862085}
     2086
    20872087///////////////////////////////////////////////////////////////////////////////
    20882088proc Funktion100
    … …  
    20992099  return(Show(@f), @tp);
    21002100}
     2101
    21012102///////////////////////////////////////////////////////////////////////////////
    21022103proc Funktion101
    … …  
    21132114  return(Show(@f), @tp);
    21142115}
     2116
     2117///////////////////////////////////////////////////////////////////////////////
     2118
    21152119///////////////////////////////////////////////////////////////////////////////
    21162120proc internalfunctions
    … …  
    22122216//proc internalfunctions
    22132217//proc tschirnhaus (poly @f, poly @x)
     2218///////////////////////////////////////////////////////////////////////////////
     2219//---------------------------- initialisation ---------------------------------
     2220//------------------------------ output ---------------------------------------
Note: See TracChangeset for help on using the changeset viewer.