Changeset 6e17f8 in git for Singular/LIB

Timestamp:

Oct 7, 2010, 8:46:50 PM (14 years ago)

Author:

Anne Frühbis-Krüger <anne@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

6237df24aaf50dfa474a5ed678260dbeb6672678

Parents:

d0579a05a4cf0bbd2234e1d03abd8a0e56876f0b

Message:

anne: added OVERVIEW and REFERENCES to resjung.lib

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

File:

• Singular/LIB/resjung.lib (modified) (40 diffs)

Singular/LIB/resjung.lib

@@ -1 @@
-//
 version="$Id$";
-category="Commutative Algebra";
+category="Algebraic Geometry";
 info="
 LIBRARY:  resjung.lib      Resolution of surface singularities (Desingularization)
-                           by Jung's Algorithm
-AUTHORS:  Philipp Renner,   philipp_renner@web.de
-          Anne Fruehbis-Krueger, anne@math.uni-hannover.de
-
-PROCEDURES:
- jungresolve(J,i)  computes a resolution of the surface given by the
+                           by Jung's Algorithm 
+AUTHORS:  Philipp Renner,   philipp_renner@web.de  
+@*        Anne Fruehbis-Krueger, anne@math.uni-hannover.de
+OVERVIEW: This library implements resolution of singularities by Jung's algorithm,
+@*        which is only applicable to surfaces and persues the following strategy:
+@*        1) project surface to the plane
+@*        2) resolve singularities of the branch locus
+@*        3) pull-back the original surface by this resolution morphism
+@*        4) normalize the resulting surface so that the remaining singularities
+@*           are of Hirzebruch-Jung type
+@*        5) resolve Hirzebruch-Jung singularities explicitly
+@*        Currently, the Hirzebruch-Jung singularities are resolved by calling
+@*        the procedure resolve from the library resolve.lib, because this is not
+@*        overly expensive and the original last step of Jung's algorithm is not
+@*        implemented yet.
+REFERENCES: 
+[1] Jung, H.: Darstellung der Funktionen eines algebraischen Körpers zweier unabhÀngigen 
+@*  VerÀnderlichen x,y in der Umgebung x=a, y= b, Journal fÌr Reine und Angewandte 
+@*  Mathematik 133: 289–314 (1908)
+@*  (the origin of this method)
+[2] J.Kollar: Lectures on Resolution of Singularities, Princeton University Press (2007)
+@*  (contains large overview over various known methods for curves and surfaces as well as
+@*   a detailed description of the approach in the general case)
+ 
+MAIN PROCEDURES:
+ jungresolve(J,i)  computes a resolution of the surface given by the 
                    ideal J using Jungs Method
+
+AUXILLARY PROCEDURES:
  clocus(J)         computes the critical locus of the projection of V(J)
-                   onto the coordinate plane of the last two coordinates
- embR(C)           computes a strong embedded resolution of
+                   onto the coordinate plane of the last two coordinates 
+ embR(C)           computes a strong embedded resolution of 
                    the plane curve V(C)
  jungnormal(J,i)   computes intermediate step in Jung's algorithm
-                   such that all singularities are of Hirzebruch-Jung type
+                   such that all singularities are of Hirzebruch-Jung type 
 ";
 
@@ -29 +50 @@
 //Critical locus for the Weierstrass map induced by the noether normalization
 //----------------------------------------------------------------------------
-proc clocus(ideal id)
+proc clocus(ideal id)      
 "USAGE:  clocus(ideal J);
 @*       J = ideal
-ASSUME:  J  = two dimensional ideal in noether position with respect
-         to the last two variables
+ASSUME:  J  = two dimensional ideal in noether position with respect   
+         to the last two variables 
 RETURN:  A ring containing the ideal Clocus respresenting the critical
          locus of the projection V(J)-->C^2 onto the coordinate plane
@@ -51 +72 @@
       lowdim = intersect(lowdim,l[j]);
     }
-  }
+  } 
   //lowdim = radical(lowdim);  // affects performance
-  ideal I = l[size(l)];
+  ideal I = l[size(l)];  
   poly product=1;
-  kill l;
-  for(i=1; i < n-1; i++){
+  kill l;  
+  for(i=1; i < n-1; i++){ 
   //elimination of all variables exept var(i),var(n-1),var(n)
     intvec v;
@@ -77 +98 @@
     ringl[3]=ll;
     kill l,ll;
-    def R = ring(ringl); //now x_j > x_i > x_n-1 > x_n forall j != i,n-1,n
+    def R = ring(ringl); //now x_j > x_i > x_n-1 > x_n forall j != i,n-1,n 
     setring R;
     ideal J = groebner(fetch(A,I));  //this eliminates the variables
     setring A;
-    ideal J = fetch(R,J);
+    ideal J = fetch(R,J);   
     attrib(J,"isPrincipal",0);
     if(size(J)==1){
@@ -89 +110 @@
     if(attrib(J,"isPrincipal")==0){
       setring R;
-      for(j = 1;j<=size(J);j++)
-      {   //determines the monic polynomial in var(i) with coefficents in C2
+      for(j = 1;j<=size(J);j++){   //determines the monic polynomial in var(i) with coefficents in C2
         if(defined(w)) {kill w;}
         intvec w = leadexp(J[j]);
@@ -108 +128 @@
       setring A;
     }
-    //Product of the discriminants, which lies in C2:
-    product = product*resultant(J[index],diff(J[index],var(i)),var(i));
+    product = product*resultant(J[index],diff(J[index],var(i)),var(i));   //Product of the discriminants, which lies in C2
     kill index,J,v;
   }
@@ -116 +135 @@
   ideal Clocus = imap(A,product);      //the critical locus is contained in this
   ideal I = preimage(A,LastTwo,lowdim);
-  //radical is necessary since the resultant is not reduced in general:
-  Clocus = radical(intersect(Clocus,I));
+  Clocus = radical(intersect(Clocus,I));  //radical is necessary since the resultant is not reduced in general
   export(Clocus);
   return(C2);
@@ -133 +151 @@
 ///////////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
-// Build the fibre product of the embedded resolution and
+// Build the fibre product of the embedded resolution and 
 // the coordinate ring of the variety
 //-----------------------------------------------------------------------------
-static
+static 
 proc buildFP(list embR,ideal NoetherN, map phi){
   def A = basering;
@@ -147 +165 @@
     setring R;
     list temp = ringlist(A);
-// create data for the new ring
+// create data for the new ring 
 // 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]
     for(j = 1; j<= nvars(R);j++){
@@ -159 +177 @@
     int m = size(J);
     def R2 = ring(temp);
-    kill temp;
+    kill temp; 
     setring R2;
     ideal Temp=0;           //defines map from R to R2 which is the inclusion
@@ -173 +191 @@
     FibPMI= FibPMI+ideal(f(J));
     map FibMap = A,FibPMI;
-    kill f,FibPMI;
+    kill f,FibPMI;  
     ideal TotalT = groebner(FibMap(NoetherN));
     ideal QIdeal = TotalT;
@@ -191 +209 @@
 // embedded resolution for curves -- optimized for our situation
 //-----------------------------------------------------------------------------
-proc embR(ideal C)
+proc embR(ideal C) 
 "USAGE:  embR(ideal C);
 @*       C = ideal
-ASSUME:  C  = ideal of plane curve
+ASSUME:  C  = ideal of plane curve 
 RETURN:  a list l of rings
          l[i] is a ring containing a basic object BO, the result of the
-         resolution.
+         resolution. 
 NOTE:    Algorithm does not touch normal crossings of V(C)
 EXAMPLE: example embR; shows an example
@@ -205 +223 @@
   attrib(J,"iswholeRing",1);
   list primdec = equidim(C);
-  if(size(primdec)==2){
-// zero dimensional components of the discrimiant curve
-// are smooth an cross normally so they can be ignored
+  if(size(primdec)==2){   
+// zero dimensional components of the discrimiant curve 
+// are smooth an cross normally so they can be ignored 
 // in the resolution process
     ideal Lowdim = radical(primdec[1]);
@@ -220 +238 @@
   list result = resolve2(BO);
   if(defined(Lowdim)){
-    for(int i = 1;i<=size(result);i++){
+    for(int i = 1;i<=size(result);i++){        
 // had zero dimensional components which are now added to the end result
       if(defined(R)) {kill R;}
       def R = result[i];
-      setring R;
+      setring R; 
       map f = R2,BO[5];
       BO[2]=BO[2]*f(Lowdim);
@@ -243 +261 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-static
+static 
 proc resolve2(list BO){
-// computes an embedded resolution for the basic object BO
-// and returns a list of rings with BO -- specifically optimized
-// to our situation
+// computes an embedded resolution for the basic object BO 
+// and returns a list of rings with BO -- specifically optimized 
+// to our situation 
   def H = basering;
   int i,j,k;
@@ -255 +273 @@
   result[1]=H;
   attrib(result[1],"isResolved",0);    // has only simple normal crossings
-  attrib(result[1],"smoothC",0);       // has smooth components
+  attrib(result[1],"smoothC",0);       // has smooth components 
   int safety=0;                        // number of runs restricted to 30
   while(1){
@@ -265 +283 @@
         def R = result[j];
         setring R;
-        if(attrib(result[j],"smoothC")==0){
+        if(attrib(result[j],"smoothC")==0){     
 // has possibly singular components so choose a singular point and blow up
           list primdecPC = primdecGTZ(BO[2]);
@@ -280 +298 @@
               if(defined(blowup)){kill blowup;}
               list blowup = blowUpBO(BO,primdecSL[index][2],3);
-// if it has only a rational singularity, blow it up,
+// if it has only a rational singularity, blow it up, 
 // else choose some arbitary singular point
-              if(attrib(primdecSL[1],"isRational")==0){
-// if we blew up a non rational singularity, the exeptional divisors
+              if(attrib(primdecSL[1],"isRational")==0){  
+// if we blew up a non rational singularity, the exeptional divisors 
 // are reduzible, so we need to separate them
                 for(k=1;k<=size(blowup);k++){
@@ -328 +346 @@
           kill primdecPC;
           j=p;
-          break;
-        }
-        else{
-// if it has smooth components, determine all the intersection points
+          break; 
+        }
+        else{                           
+// if it has smooth components, determine all the intersection points 
 // and check whether they are snc or not
           int count = 0;
@@ -417 +435 @@
 };
 ///////////////////////////////////////////////////////////////////////////////
-static
-proc jungfib(ideal id, int noeth)
+static 
+proc jungfib(ideal id, int noeth) 
 "USAGE:  jungfib(ideal J, int i);
 @*       J = ideal
@@ -424 +442 @@
 ASSUME:  J  = two dimensional ideal
 RETURN:  a list l of rings
-         l[i] is a ring containing two Ideals: QIdeal and BMap.
-         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
+         l[i] is a ring containing two Ideals: QIdeal and BMap. 
+         BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
          V(QIdeal) has only quasi-ordinary singularities.
-         If i!=0 then it's assumed that J is in noether position with respect
+         If i!=0 then it's assumed that J is in noether position with respect 
          to the last two variables.
-         If i=0 the algorithm computes a coordinate change such that J is in
+         If i=0 the algorithm computes a coordinate change such that J is in 
          noether position.
 EXAMPLE: none, as it is a static procedure
@@ -441 +459 @@
   ideal I = std(radical(id));
   def A = basering;
-  int n = nvars(A);
+  int n = nvars(A);                            
   if(deg(NF(1,groebner(slocus(id)))) == -1){
     list result;
@@ -454 +472 @@
   if(dim(I)<> 2){ERROR("dimension is unequal 2");}  //dummy check
 
-// Noether Normalization
+// Noether Normalization 
   if(noeth == 0){
     if(n==3){
@@ -476 +494 @@
         }
         map phi = A,NoetherPos;
-        kill i,pos,NoetherPos;
-      }
-    }
-    else{
+        kill i,pos,NoetherPos; 
+      }
+    }
+    else{ 
       map phi = A,NoetherPosition(I);
     }
-    ideal NoetherN = ideal(phi(I));
+    ideal NoetherN = ideal(phi(I));              
 //image of id under the NoetherN coordinate change
   }
@@ -489 +507 @@
     map phi = A,maxideal(1);
   }
-  kill I;
-//Critical Locus
+  kill I;  
+//Critical Locus 
   def C2 = clocus(NoetherN);
   setring C2;
-
+     
 //dim of critical locus is 0 then the normalization is an resolution
   if(dim(Clocus) == 0){
@@ -512 +530 @@
     return(result);
   }
-
-// dim of critical locus is 1, so compute embedded resolution of the discriminant curve
+   
+// dim of critical locus is 1, so compute embedded resolution of the discriminant curve 
   list embRe = embR(Clocus);
-
+  
 // build the fibreproduct
   setring A;
-  list fibreP = buildFP(embRe,NoetherN,phi);
-// a list of lists, where fibreP[i] contains the information
+  list fibreP = buildFP(embRe,NoetherN,phi);  
+// a list of lists, where fibreP[i] contains the information 
 // concerning  the i-th chart of the fibrepoduct
 // fibreP[i] is the ring; QIdeal the quotientideal; BMap is the map from A
@@ -532 +550 @@
 ASSUME:  J  = two dimensional ideal
 RETURN:  a list l of rings
-         l[k] is a ring containing two Ideals: QIdeal and BMap.
-         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
+         l[k] is a ring containing two Ideals: QIdeal and BMap. 
+         BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
          V(QIdeal) has only singularities of Hizebuch-Jung type.
-         If i!=0 then it's assumed that J is in noether position with respect
+         If i!=0 then it's assumed that J is in noether position with respect 
          to the last two variables.
-         If i=0 the algorithm computes a coordinate change such that J is in
+         If i=0 the algorithm computes a coordinate change such that J is in 
          noether position.
 EXAMPLE: example jungnormal; shows an example
@@ -587 +605 @@
 ASSUME:  J  = two dimensional ideal
 RETURN:  a list l of rings
-         l[k] is a ring containing two Ideals: QIdeal and BMap.
-         BMap defines a birational morphism from V(QIdeal)-->V(J), such that
-         V(QIdeal) is smooth. For this the algorithm computes first
+         l[k] is a ring containing two Ideals: QIdeal and BMap. 
+         BMap defines a birational morphism from V(QIdeal)-->V(J), such that 
+         V(QIdeal) is smooth. For this the algorithm computes first  
          a representation of V(J) with Hirzebruch-Jung singularities
-         and then it currently uses Villamayor's algorithm to resolve
+         and then it currently uses Villamayor's algorithm to resolve 
          these singularities.
-         If i!=0 then it's assumed that J is in noether position with respect
+         If i!=0 then it's assumed that J is in noether position with respect 
          to the last two variables.
-         If i=0 the algorithm computes a coordinate change such that J is in
+         If i=0 the algorithm computes a coordinate change such that J is in 
          noether position.
 EXAMPLE: none
@@ -637 +655 @@
   }
   return(result);
-}
+}    
 example
 {"EXAMPLE:";
@@ -651 +669 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-static
+static 
 proc NoetherP_test(ideal id){
   def A = basering;
@@ -660 +678 @@
     list L;
     intvec v = 1,1,1;
-    L[1] = "lp";
+    L[1] = "lp";     
     L[2] = v;
     kill v;
@@ -681 +699 @@
       intvec v = leadexp(I[1]);
       attrib(v,"isMonic",1);
-      for(k = 2;k<=3;k++){
+      for(k = 2;k<=3;k++){  
 // checks whether f is monic in var(i)
-        if(v[k] <> 0 || v[1] == 0){
+        if(v[k] <> 0 || v[1] == 0){ 
           attrib(v,"isMonic",0);
           j++;
@@ -699 +717 @@
     }
   }
-  else{
+  else{     
 // not yet a test for more variables
     return(index);
@@ -708 +726 @@
 //// not necessary in this setting                                    ///
 /////////////////////////////////////////////////////////////////////////
-static
-proc normalCrossing(ideal J,list E,ideal V)
+static 
+proc normalCrossing(ideal J,list E,ideal V)        
 "Internal procedure - no help and no example available
 "
@@ -715 +733 @@
    int i,d,j;
    int n=nvars(basering);
-   list E1,E2;
+   list E1,E2;                   
    ideal K,M,Estd;
    intvec v,w;
 
-   for(i=1;i<=size(E);i++)
+   for(i=1;i<=size(E);i++)  
    {
       Estd=std(E[i]+J);
@@ -728 +746 @@
    }
    E=E1;
-   for(i=1;i<=size(E);i++)
+   for(i=1;i<=size(E);i++)   
    {
       v=i;
@@ -734 +752 @@
    }
    list ll;
-   int re=1;
-
-   while((size(E1)>0)&&(re==1))
+   int re=1;         
+
+   while((size(E1)>0)&&(re==1))   
    {
-      K=E1[1][1];
-      v=E1[1][2];
+      K=E1[1][1];                 
+      v=E1[1][2];                 
       attrib(K,"isSB",1);
       E1=delete(E1,1);
-      d=n-dim(K);
-      M=minor(jacob(K),d)+K;
-      if(deg(std(M+V)[1])>0)
+      d=n-dim(K);                
+      M=minor(jacob(K),d)+K;     
+      if(deg(std(M+V)[1])>0)     
       {
          re=0;
@@ -751 +769 @@
       for(i=1;i<=size(E);i++)
       {
-         for(j=1;j<=size(v);j++){if(v[j]==i){break;}}
-         if(j<=size(v)){if(v[j]==i){i++;continue;}}
-         Estd=std(K+E[i]);
+         for(j=1;j<=size(v);j++){if(v[j]==i){break;}}  
+         if(j<=size(v)){if(v[j]==i){i++;continue;}}    
+         Estd=std(K+E[i]);                             
          w=v;
          if(deg(Estd[1])==0){i++;continue;}
-         if(d==n-dim(Estd))
+         if(d==n-dim(Estd))                            
          {
             if(deg(std(Estd+V)[1])>0)
@@ -846 +864 @@
         ideal norid = imap(R3,norid);
         ideal normap = imap(R3,normap);
-        kill R3;
+        kill R3; 
         map f = R,normap;
         if(defined(BMap)){kill BMap;}
@@ -900 +918 @@
 //////////////////////////////////////////////////////////////////////////////
 
+
+
+
+
+    
+