Changeset 6e45c1 in git


Ignore:
Timestamp:
Oct 8, 2010, 11:51:44 AM (13 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '5b153614cbc72bfa198d75b1e9e33dab2645d9fe')
Children:
0291940c9ec5aa05557656c2e97b801e2246c2fa
Parents:
4c4e0dd3d09608d110183de35eaa8e1c548721ff
Message:
syntax fix

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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/resjung.lib

    r4c4e0d r6e45c1  
     1//
    12version="$Id$";
    23category="Algebraic Geometry";
    34info="
    45LIBRARY:  resjung.lib      Resolution of surface singularities (Desingularization)
    5                            by Jung's Algorithm 
    6 AUTHORS:  Philipp Renner,   philipp_renner@web.de 
     6                           by Jung's Algorithm
     7AUTHORS:  Philipp Renner,   philipp_renner@web.de
    78@*        Anne Fruehbis-Krueger, anne@math.uni-hannover.de
    89OVERVIEW: This library implements resolution of singularities by Jung's algorithm,
     
    1819@*        overly expensive and the original last step of Jung's algorithm is not
    1920@*        implemented yet.
    20 REFERENCES:
    21 [1] Jung, H.: Darstellung der Funktionen eines algebraischen Körpers zweier unabhÀngigen
    22 @*  VerÀnderlichen x,y in der Umgebung x=a, y= b, Journal fÃŒr Reine und Angewandte
    23 @*  Mathematik 133: 289–314 (1908)
     21REFERENCES:
     22[1] Jung, H.: Darstellung der Funktionen eines algebraischen Koerpers zweier unabhaengigen
     23Veraenderlichen x,y in der Umgebung x=a, y= b, Journal fuer Reine und Angewandte Mathematik 133,289-314 (1908)
    2424@*  (the origin of this method)
    2525[2] J.Kollar: Lectures on Resolution of Singularities, Princeton University Press (2007)
    2626@*  (contains large overview over various known methods for curves and surfaces as well as
    2727@*   a detailed description of the approach in the general case)
    28  
    29 MAIN PROCEDURES:
    30  jungresolve(J,i)  computes a resolution of the surface given by the 
     28
     29PROCEDURES:
     30 jungresolve(J,i)  computes a resolution of the surface given by the
    3131                   ideal J using Jungs Method
    3232
    33 AUXILLARY PROCEDURES:
    3433 clocus(J)         computes the critical locus of the projection of V(J)
    35                    onto the coordinate plane of the last two coordinates 
    36  embR(C)           computes a strong embedded resolution of 
     34                   onto the coordinate plane of the last two coordinates
     35 embR(C)           computes a strong embedded resolution of
    3736                   the plane curve V(C)
    3837 jungnormal(J,i)   computes intermediate step in Jung's algorithm
    39                    such that all singularities are of Hirzebruch-Jung type 
     38                   such that all singularities are of Hirzebruch-Jung type
    4039";
    4140
     
    5049//Critical locus for the Weierstrass map induced by the noether normalization
    5150//----------------------------------------------------------------------------
    52 proc clocus(ideal id)     
     51proc clocus(ideal id)
    5352"USAGE:  clocus(ideal J);
    5453@*       J = ideal
    55 ASSUME:  J  = two dimensional ideal in noether position with respect   
    56          to the last two variables 
     54ASSUME:  J  = two dimensional ideal in noether position with respect
     55         to the last two variables
    5756RETURN:  A ring containing the ideal Clocus respresenting the critical
    5857         locus of the projection V(J)-->C^2 onto the coordinate plane
     
    7271      lowdim = intersect(lowdim,l[j]);
    7372    }
    74   } 
     73  }
    7574  //lowdim = radical(lowdim);  // affects performance
    76   ideal I = l[size(l)]; 
     75  ideal I = l[size(l)];
    7776  poly product=1;
    78   kill l; 
    79   for(i=1; i < n-1; i++){ 
     77  kill l;
     78  for(i=1; i < n-1; i++){
    8079  //elimination of all variables exept var(i),var(n-1),var(n)
    8180    intvec v;
     
    9897    ringl[3]=ll;
    9998    kill l,ll;
    100     def R = ring(ringl); //now x_j > x_i > x_n-1 > x_n forall j != i,n-1,n 
     99    def R = ring(ringl); //now x_j > x_i > x_n-1 > x_n forall j != i,n-1,n
    101100    setring R;
    102101    ideal J = groebner(fetch(A,I));  //this eliminates the variables
    103102    setring A;
    104     ideal J = fetch(R,J);   
     103    ideal J = fetch(R,J);
    105104    attrib(J,"isPrincipal",0);
    106105    if(size(J)==1){
     
    151150///////////////////////////////////////////////////////////////////////////////
    152151//-----------------------------------------------------------------------------
    153 // Build the fibre product of the embedded resolution and 
     152// Build the fibre product of the embedded resolution and
    154153// the coordinate ring of the variety
    155154//-----------------------------------------------------------------------------
    156 static 
     155static
    157156proc buildFP(list embR,ideal NoetherN, map phi){
    158157  def A = basering;
     
    165164    setring R;
    166165    list temp = ringlist(A);
    167 // create data for the new ring 
     166// create data for the new ring
    168167// e.g. if A=K[x_1,..,x_n] and R=K[y_1,..,y_m], K[x_1,..,x_n-2,y_1,..,y_m]
    169168    for(j = 1; j<= nvars(R);j++){
     
    177176    int m = size(J);
    178177    def R2 = ring(temp);
    179     kill temp; 
     178    kill temp;
    180179    setring R2;
    181180    ideal Temp=0;           //defines map from R to R2 which is the inclusion
     
    191190    FibPMI= FibPMI+ideal(f(J));
    192191    map FibMap = A,FibPMI;
    193     kill f,FibPMI; 
     192    kill f,FibPMI;
    194193    ideal TotalT = groebner(FibMap(NoetherN));
    195194    ideal QIdeal = TotalT;
     
    209208// embedded resolution for curves -- optimized for our situation
    210209//-----------------------------------------------------------------------------
    211 proc embR(ideal C) 
     210proc embR(ideal C)
    212211"USAGE:  embR(ideal C);
    213212@*       C = ideal
    214 ASSUME:  C  = ideal of plane curve 
     213ASSUME:  C  = ideal of plane curve
    215214RETURN:  a list l of rings
    216215         l[i] is a ring containing a basic object BO, the result of the
    217          resolution. 
     216         resolution.
    218217NOTE:    Algorithm does not touch normal crossings of V(C)
    219218EXAMPLE: example embR; shows an example
     
    223222  attrib(J,"iswholeRing",1);
    224223  list primdec = equidim(C);
    225   if(size(primdec)==2){   
    226 // zero dimensional components of the discrimiant curve 
    227 // are smooth an cross normally so they can be ignored 
     224  if(size(primdec)==2){
     225// zero dimensional components of the discrimiant curve
     226// are smooth an cross normally so they can be ignored
    228227// in the resolution process
    229228    ideal Lowdim = radical(primdec[1]);
     
    238237  list result = resolve2(BO);
    239238  if(defined(Lowdim)){
    240     for(int i = 1;i<=size(result);i++){       
     239    for(int i = 1;i<=size(result);i++){
    241240// had zero dimensional components which are now added to the end result
    242241      if(defined(R)) {kill R;}
    243242      def R = result[i];
    244       setring R; 
     243      setring R;
    245244      map f = R2,BO[5];
    246245      BO[2]=BO[2]*f(Lowdim);
     
    261260}
    262261///////////////////////////////////////////////////////////////////////////////
    263 static 
     262static
    264263proc resolve2(list BO){
    265 // computes an embedded resolution for the basic object BO 
    266 // and returns a list of rings with BO -- specifically optimized 
    267 // to our situation 
     264// computes an embedded resolution for the basic object BO
     265// and returns a list of rings with BO -- specifically optimized
     266// to our situation
    268267  def H = basering;
    269268  int i,j,k;
     
    273272  result[1]=H;
    274273  attrib(result[1],"isResolved",0);    // has only simple normal crossings
    275   attrib(result[1],"smoothC",0);       // has smooth components 
     274  attrib(result[1],"smoothC",0);       // has smooth components
    276275  int safety=0;                        // number of runs restricted to 30
    277276  while(1){
     
    283282        def R = result[j];
    284283        setring R;
    285         if(attrib(result[j],"smoothC")==0){     
     284        if(attrib(result[j],"smoothC")==0){
    286285// has possibly singular components so choose a singular point and blow up
    287286          list primdecPC = primdecGTZ(BO[2]);
     
    298297              if(defined(blowup)){kill blowup;}
    299298              list blowup = blowUpBO(BO,primdecSL[index][2],3);
    300 // if it has only a rational singularity, blow it up, 
     299// if it has only a rational singularity, blow it up,
    301300// else choose some arbitary singular point
    302               if(attrib(primdecSL[1],"isRational")==0){ 
    303 // if we blew up a non rational singularity, the exeptional divisors 
     301              if(attrib(primdecSL[1],"isRational")==0){
     302// if we blew up a non rational singularity, the exeptional divisors
    304303// are reduzible, so we need to separate them
    305304                for(k=1;k<=size(blowup);k++){
     
    346345          kill primdecPC;
    347346          j=p;
    348           break; 
    349         }
    350         else{                           
    351 // if it has smooth components, determine all the intersection points 
     347          break;
     348        }
     349        else{
     350// if it has smooth components, determine all the intersection points
    352351// and check whether they are snc or not
    353352          int count = 0;
     
    435434};
    436435///////////////////////////////////////////////////////////////////////////////
    437 static 
    438 proc jungfib(ideal id, int noeth) 
     436static
     437proc jungfib(ideal id, int noeth)
    439438"USAGE:  jungfib(ideal J, int i);
    440439@*       J = ideal
     
    442441ASSUME:  J  = two dimensional ideal
    443442RETURN:  a list l of rings
    444          l[i] is a ring containing two Ideals: QIdeal and BMap. 
    445          BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
     443         l[i] is a ring containing two Ideals: QIdeal and BMap.
     444         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
    446445         V(QIdeal) has only quasi-ordinary singularities.
    447          If i!=0 then it's assumed that J is in noether position with respect 
     446         If i!=0 then it's assumed that J is in noether position with respect
    448447         to the last two variables.
    449          If i=0 the algorithm computes a coordinate change such that J is in 
     448         If i=0 the algorithm computes a coordinate change such that J is in
    450449         noether position.
    451450EXAMPLE: none, as it is a static procedure
     
    459458  ideal I = std(radical(id));
    460459  def A = basering;
    461   int n = nvars(A);                           
     460  int n = nvars(A);
    462461  if(deg(NF(1,groebner(slocus(id)))) == -1){
    463462    list result;
     
    472471  if(dim(I)<> 2){ERROR("dimension is unequal 2");}  //dummy check
    473472
    474 // Noether Normalization 
     473// Noether Normalization
    475474  if(noeth == 0){
    476475    if(n==3){
     
    494493        }
    495494        map phi = A,NoetherPos;
    496         kill i,pos,NoetherPos; 
    497       }
    498     }
    499     else{ 
     495        kill i,pos,NoetherPos;
     496      }
     497    }
     498    else{
    500499      map phi = A,NoetherPosition(I);
    501500    }
    502     ideal NoetherN = ideal(phi(I));             
     501    ideal NoetherN = ideal(phi(I));
    503502//image of id under the NoetherN coordinate change
    504503  }
     
    507506    map phi = A,maxideal(1);
    508507  }
    509   kill I; 
    510 //Critical Locus 
     508  kill I;
     509//Critical Locus
    511510  def C2 = clocus(NoetherN);
    512511  setring C2;
    513      
     512
    514513//dim of critical locus is 0 then the normalization is an resolution
    515514  if(dim(Clocus) == 0){
     
    530529    return(result);
    531530  }
    532    
    533 // dim of critical locus is 1, so compute embedded resolution of the discriminant curve 
     531
     532// dim of critical locus is 1, so compute embedded resolution of the discriminant curve
    534533  list embRe = embR(Clocus);
    535  
     534
    536535// build the fibreproduct
    537536  setring A;
    538   list fibreP = buildFP(embRe,NoetherN,phi); 
    539 // a list of lists, where fibreP[i] contains the information 
     537  list fibreP = buildFP(embRe,NoetherN,phi);
     538// a list of lists, where fibreP[i] contains the information
    540539// concerning  the i-th chart of the fibrepoduct
    541540// fibreP[i] is the ring; QIdeal the quotientideal; BMap is the map from A
     
    550549ASSUME:  J  = two dimensional ideal
    551550RETURN:  a list l of rings
    552          l[k] is a ring containing two Ideals: QIdeal and BMap. 
    553          BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
     551         l[k] is a ring containing two Ideals: QIdeal and BMap.
     552         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
    554553         V(QIdeal) has only singularities of Hizebuch-Jung type.
    555          If i!=0 then it's assumed that J is in noether position with respect 
     554         If i!=0 then it's assumed that J is in noether position with respect
    556555         to the last two variables.
    557          If i=0 the algorithm computes a coordinate change such that J is in 
     556         If i=0 the algorithm computes a coordinate change such that J is in
    558557         noether position.
    559558EXAMPLE: example jungnormal; shows an example
     
    605604ASSUME:  J  = two dimensional ideal
    606605RETURN:  a list l of rings
    607          l[k] is a ring containing two Ideals: QIdeal and BMap. 
    608          BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
    609          V(QIdeal) is smooth. For this the algorithm computes first 
     606         l[k] is a ring containing two Ideals: QIdeal and BMap.
     607         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
     608         V(QIdeal) is smooth. For this the algorithm computes first
    610609         a representation of V(J) with Hirzebruch-Jung singularities
    611          and then it currently uses Villamayor's algorithm to resolve 
     610         and then it currently uses Villamayor's algorithm to resolve
    612611         these singularities.
    613          If i!=0 then it's assumed that J is in noether position with respect 
     612         If i!=0 then it's assumed that J is in noether position with respect
    614613         to the last two variables.
    615          If i=0 the algorithm computes a coordinate change such that J is in 
     614         If i=0 the algorithm computes a coordinate change such that J is in
    616615         noether position.
    617616EXAMPLE: none
     
    655654  }
    656655  return(result);
    657 }   
     656}
    658657example
    659658{"EXAMPLE:";
     
    669668}
    670669///////////////////////////////////////////////////////////////////////////////
    671 static 
     670static
    672671proc NoetherP_test(ideal id){
    673672  def A = basering;
     
    678677    list L;
    679678    intvec v = 1,1,1;
    680     L[1] = "lp";     
     679    L[1] = "lp";
    681680    L[2] = v;
    682681    kill v;
     
    699698      intvec v = leadexp(I[1]);
    700699      attrib(v,"isMonic",1);
    701       for(k = 2;k<=3;k++){ 
     700      for(k = 2;k<=3;k++){
    702701// checks whether f is monic in var(i)
    703         if(v[k] <> 0 || v[1] == 0){ 
     702        if(v[k] <> 0 || v[1] == 0){
    704703          attrib(v,"isMonic",0);
    705704          j++;
     
    717716    }
    718717  }
    719   else{     
     718  else{
    720719// not yet a test for more variables
    721720    return(index);
     
    726725//// not necessary in this setting                                    ///
    727726/////////////////////////////////////////////////////////////////////////
    728 static 
    729 proc normalCrossing(ideal J,list E,ideal V)       
     727static
     728proc normalCrossing(ideal J,list E,ideal V)
    730729"Internal procedure - no help and no example available
    731730"
     
    733732   int i,d,j;
    734733   int n=nvars(basering);
    735    list E1,E2;                   
     734   list E1,E2;
    736735   ideal K,M,Estd;
    737736   intvec v,w;
    738737
    739    for(i=1;i<=size(E);i++) 
     738   for(i=1;i<=size(E);i++)
    740739   {
    741740      Estd=std(E[i]+J);
     
    746745   }
    747746   E=E1;
    748    for(i=1;i<=size(E);i++)   
     747   for(i=1;i<=size(E);i++)
    749748   {
    750749      v=i;
     
    752751   }
    753752   list ll;
    754    int re=1;         
    755 
    756    while((size(E1)>0)&&(re==1))   
     753   int re=1;
     754
     755   while((size(E1)>0)&&(re==1))
    757756   {
    758       K=E1[1][1];                 
    759       v=E1[1][2];                 
     757      K=E1[1][1];
     758      v=E1[1][2];
    760759      attrib(K,"isSB",1);
    761760      E1=delete(E1,1);
    762       d=n-dim(K);               
    763       M=minor(jacob(K),d)+K;     
    764       if(deg(std(M+V)[1])>0)     
     761      d=n-dim(K);
     762      M=minor(jacob(K),d)+K;
     763      if(deg(std(M+V)[1])>0)
    765764      {
    766765         re=0;
     
    769768      for(i=1;i<=size(E);i++)
    770769      {
    771          for(j=1;j<=size(v);j++){if(v[j]==i){break;}} 
    772          if(j<=size(v)){if(v[j]==i){i++;continue;}}   
    773          Estd=std(K+E[i]);                             
     770         for(j=1;j<=size(v);j++){if(v[j]==i){break;}}
     771         if(j<=size(v)){if(v[j]==i){i++;continue;}}
     772         Estd=std(K+E[i]);
    774773         w=v;
    775774         if(deg(Estd[1])==0){i++;continue;}
    776          if(d==n-dim(Estd))                           
     775         if(d==n-dim(Estd))
    777776         {
    778777            if(deg(std(Estd+V)[1])>0)
     
    864863        ideal norid = imap(R3,norid);
    865864        ideal normap = imap(R3,normap);
    866         kill R3; 
     865        kill R3;
    867866        map f = R,normap;
    868867        if(defined(BMap)){kill BMap;}
     
    918917//////////////////////////////////////////////////////////////////////////////
    919918
    920 
    921 
    922 
    923 
    924    
    925      
Note: See TracChangeset for help on using the changeset viewer.