Changeset 71673b in git

Timestamp:

Sep 22, 2010, 6:51:00 PM (13 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')

Children:

f48d7b69ebab215998125e1e8020cc229bf8f040

Parents:

8c87110fe9bfff712ab72ad60f3ed035b70989e2

Message:

format

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

File:

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

Singular/LIB/resjung.lib

@@ -3 +3 @@
 info="
 LIBRARY:  resjung.lib      Resolution of surface singularities (Desingularization)
-                           by Jung's Algorithm 
-AUTHORS:  Philipp Renner,   philipp_renner@web.de  
+                           by Jung's Algorithm
+AUTHORS:  Philipp Renner,   philipp_renner@web.de
           Anne Fruehbis-Krueger, anne@math.uni-hannover.de
 
 MAIN PROCEDURES:
- jungresolve(J,i)  computes a resolution of the surface given by the 
+ 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
 ";
 
@@ -30 +30 @@
 //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
@@ -52 +52 @@
       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;
@@ -78 +78 @@
     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){
@@ -131 +131 @@
 ///////////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
-// 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;
@@ -145 +145 @@
     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++){
@@ -157 +157 @@
     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
@@ -171 +171 @@
     FibPMI= FibPMI+ideal(f(J));
     map FibMap = A,FibPMI;
-    kill f,FibPMI;  
+    kill f,FibPMI;
     ideal TotalT = groebner(FibMap(NoetherN));
     ideal QIdeal = TotalT;
@@ -189 +189 @@
 // 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
@@ -203 +203 @@
   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]);
@@ -218 +218 @@
   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);
@@ -241 +241 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-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;
@@ -253 +253 @@
   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){
@@ -263 +263 @@
         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]);
@@ -278 +278 @@
               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++){
@@ -326 +326 @@
           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;
@@ -415 +415 @@
 };
 ///////////////////////////////////////////////////////////////////////////////
-static 
-proc jungfib(ideal id, int noeth) 
+static
+proc jungfib(ideal id, int noeth)
 "USAGE:  jungfib(ideal J, int i);
 @*       J = ideal
@@ -422 +422 @@
 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
@@ -439 +439 @@
   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;
@@ -452 +452 @@
   if(dim(I)<> 2){ERROR("dimension is unequal 2");}  //dummy check
 
-// Noether Normalization 
+// Noether Normalization
   if(noeth == 0){
     if(n==3){
@@ -474 +474 @@
         }
         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
   }
@@ -487 +487 @@
     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){
@@ -510 +510 @@
     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
@@ -530 +530 @@
 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
@@ -585 +585 @@
 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
@@ -635 +635 @@
   }
   return(result);
-}    
+}
 example
 {"EXAMPLE:";
@@ -649 +649 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-static 
+static
 proc NoetherP_test(ideal id){
   def A = basering;
@@ -658 +658 @@
     list L;
     intvec v = 1,1,1;
-    L[1] = "lp";     
+    L[1] = "lp";
     L[2] = v;
     kill v;
@@ -679 +679 @@
       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++;
@@ -697 +697 @@
     }
   }
-  else{     
+  else{
 // not yet a test for more variables
     return(index);
@@ -706 +706 @@
 //// 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
 "
@@ -713 +713 @@
    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);
@@ -726 +726 @@
    }
    E=E1;
-   for(i=1;i<=size(E);i++)   
+   for(i=1;i<=size(E);i++)
    {
       v=i;
@@ -732 +732 @@
    }
    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;
@@ -749 +749 @@
       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)
@@ -844 +844 @@
         ideal norid = imap(R3,norid);
         ideal normap = imap(R3,normap);
-        kill R3; 
+        kill R3;
         map f = R,normap;
         if(defined(BMap)){kill BMap;}
@@ -898 +898 @@
 //////////////////////////////////////////////////////////////////////////////
 
-
-
-
-
-    
-