Changeset f0df61e in git

Timestamp:

Dec 11, 2000, 3:26:43 PM (23 years ago)

Author:

Mathias Schulze <mschulze@…>

Branches:

(u'spielwiese', '4a9821a93ffdc22a6696668bd4f6b8c9de3e6c5f')

Children:

1ed86cb72e1ab73da24e5b2690e172addcdc93f7

Parents:

bde46a274a10e7a9dd0db93b7814c2ebaae0af74

Message:

*** empty log message ***


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

File:

• Singular/LIB/reesclos.lib (modified) (34 diffs)

Singular/LIB/reesclos.lib

@@ -3 +3 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$id reesclos.lib,v 1.28 2000/10/19 hirsch Exp $";
+version="$id reesclos.lib,v 1.30 2000/12/5 hirsch Exp $";
 
 info="
 LIBRARY:     reesclos.lib
-AUTHOR:      Tobias Hirsch, email: hirsch@mathematik.uni-kl.de
-PROCEDURES:  ReesAlgebra  - computes the Rees Algebra of an ideal
-             NormalI      - computes the integral closure of an ideal using its
-                            Rees Algebra
+AUTHOR:      Tobias Hirsch, email: hirsch@math.tu-cottbus.de
+
+OVERVIEW:
+ A library to compute the integral closure of an ideal I in a polynomial ring
+ R=k[x(1),...,x(n)] using the Rees Algebra R[It] of I. It computes the integral
+ closure of R[It] (in the same manner as done in the library 'normal.lib');
+ which is a graded subalgebra of R[t]. The degree-k-component is the integral
+ closure of the k-th power of I.
+
+PROCEDURES:  
+ ReesAlgebra(I);        computes the Rees Algebra of an ideal I
+ NormalI(I[,p[,r]]);    computes the integral closure of an ideal I using R[It]
 ";
 
-LIB "normal.lib";       // for HomJJ
+LIB "normal.lib";       // for HomJJ 
+LIB "standard.lib";     // for groebner
 
 ///////////////////////////////////////////////////////////////////////////////
 
 proc ReesAlgebra (ideal I)
-"USAGE:   ReesAlgebra (I); I = ideal
+"USAGE:    ReesAlgebra (I); I = ideal
 COMPUTE:  The Rees algebra R[I*t] as an affine ring, where I is an ideal in R
 RETURN:   a list containing two rings:
@@ -36 +45 @@
   ideal m = maxideal(1);
 
-
+  
   // Create a new ring with variables for each generator of I
 
   execute ("ring Rees = "+oldchar+",("+oldvar+",U(1.."+string(n)+")),dp");
 
-
+ 
   // Kxt is the old ring with additional variable t
   // Here I -> t*I, so the generators of I generate the subalgebra R[It] in Kxt
@@ -51 +60 @@
   for (k=1;k<=n;k++)
   {
-    I[k]=t*I[k];
-  }
-
+    I[k]=t*I[k]; 
+  }
+  
 
   // Now we map from Rees to Kxt, identity on the original variables, and
@@ -68 +77 @@
   ideal ker = preimage(Kxt,phi,zero);
   export (ker);
-
+ 
   list result = Rees,Kxt;
-
+  
   return(result);
-
+ 
 }
 example
 {
+  "EXAMPLE:"; echo=2;
   ring R = 0,(x,y),dp;
   ideal I = x2,xy4,y5;
@@ -84 +94 @@
   ker;                   // R[I*t] is isomorphic to Rees/ker
 }
-
+ 
 
 ////////////////////////////////////////////////////////////////////////////
@@ -90 +100 @@
 static
 proc ClosureRees (list L)
-"USAGE:   ClosureRees (L); L a list containing
-          - a ring L[1], inside L[1] an ideal ker such that L[1]/ker is
+"USAGE:    ClosureRees (L); L a list containing 
+          - a ring L[1], inside L[1] an ideal ker such that L[1]/ker is 
             isomorphic to the Rees Algebra R[It] of an ideal I in k[x]
           - a ring L[2]=k[x,t], inside L[1] an ideal mapI defining the
             map L[1] --> L[2] with image R[It]
 COMPUTE:  quotients of elements of k[x,t] representing generators of the
-          integral closure of R[It]
+          integral closure of R[It] 
 RETURN:   a list images, the first size(images)-1 entries are the nu-
           merators of the generators, the last one is the universal deno-
@@ -102 +112 @@
 "
 {
-  int dblvl=printlevel-voice+2;   // toggles how much data is printed
+  int dblvl=printlevel-voice+2;   // toggles how much data is printed 
                                   // during the procedure
 
@@ -126 +136 @@
   {
     "// STEP 1: Compute the integral closure of R[It]";
-  }
+  } 
 
   list RS;
@@ -176 +186 @@
         list JM=groebner(sin),sin;
       }
-
+ 
       if (dim(JM[1])==0 && homog(SM[2])==1)
       {
         isIsoSing=1;
       }
-      J=equiRadical(JM[2]);
+      J=equiRadical(JM[2]); 
     }
     else
@@ -194 +204 @@
       }
     }
-
+    
     if (dblvl>0)
     {
@@ -204 +214 @@
     JM =J,J;
     poly nzd=SL[1];           // universal denominator for HomJJ
-
+    
     if (dblvl>0)
     {
@@ -228 +238 @@
     {                         // ring R(i+1)
       ideal MJ=JM[2];
-
-      def R(i+1)=RS[1];       // the data of and some variable decla-
+ 
+      def R(i+1)=RS[1];       // the data of and some variable decla- 
       setring R(i+1);         // rations in R(i+1) needed in STEP 2
       ideal ker(i+1)=endid;
@@ -237 +247 @@
       if (isIsoSing==0)       // fetch the singular locus if it is not
       {                       // an isolated singularity
-        list JM=mstd(simplify(phi(MJ)+ker(i+1),4));
+        list JM=mstd(simplify(phi(MJ)+ker(i+1),4)); 
       }
       i++;
@@ -245 +255 @@
   if (i==1)                     // R[It] (and thus I) was integrally
   {                             // closed ==> we're already done
-    list result="closed";
-    return(result);
+        list result="closed";
+        return(result);
   }
 
@@ -261 +271 @@
   list preimages;          // here the fractions are stored in the
                            // form var(j)=preimages[j]/preimages[length+1]
-                           // ('=' means identification via the inclusion)
+                           // ('=' means identification via the inclusion) 
                            // the last entry corresponds to nzd in R(i)
 
@@ -291 +301 @@
     for (k=i;k>1;k--)
     {
-      // clear the fraction in the representation in R(i)
-
-      p=p*phi(nzd);
+      // clear the fraction in the representation in R(i)    
+
+      p=p*phi(nzd);      
 
       // compute the preimage of [p mod ker(k)] under phi in R(k-1):
@@ -302 +312 @@
          // compute this normal form h...
 
-      if (j==1)    // in the first iteration: construct S(k)=R(k)[Z], fetch
+      if (j==1)    // in the first iteration: construct S(k)=R(k)[Z], fetch 
                    // endphi (the ideal defining phi) and ker(k) and construct
                    // the ideal from above
       {
-        execute ("ring S(k) = "+charstr(R(k))+",("+varstr(R(k))+",Z(1.."
-                 +string(ncols(endphi))+")),(dp("+string(nvars(R(k)))
-                 +"),dp("+string(ncols(endphi))+"));");
+        execute ("ring S(k) = "+charstr(R(k))+",("+varstr(R(k))+",Z(1.."+string(ncols(endphi))+")),(dp("+string(nvars(R(k)))+"),dp("+string(ncols(endphi))+"));");
         ideal endphi = imap(R(k),endphi);
         ideal J = imap(R(k),ker(k));
@@ -324 +332 @@
       }
 
-      // and compute h(vars(R(k-1)))
+         // and compute h(vars(R(k-1)))
 
       setring R(k-1);
@@ -358 +366 @@
 
   // at the end: go back to the original basering and construct gene-
-  // rators of the closure of I
+  // rators of the closure of I 
 
   setring Kxt;
   map psi=R(1),mapI;              // from ReesAlgebra: the map Rees->Kxt
 
-  list images=psi(preimages);
-
+  list images=psi(preimages);    
+  
   if (dblvl>-1)
   {
@@ -395 +403 @@
 static
 proc ClosurePower(list images, list #)
-"USAGE:   ClosurePower (L [,#]);
+"USAGE:    ClosurePower (L [,#]); 
           - L a list containing generators of the closure of R[It] in k[x,t]
             (the first size(L)-1 elements are the numerators, the last one
             is the denominator)
-          - if # is given: #[1] is an integer, compute generators for the
+          - if # is given: #[1] is an integer, compute generators for the 
                            closure of I, I^2, ..., I^#[1]
 COMPUTE:  the integral closure of I, ... I^#[1]. If # is not given, compute
@@ -405 +413 @@
           in the closure of R[It] (so this is the last one that is not just
           the sum/product of the above ones).
-RETURN:   a list containing generators of the closure of the desired powers
-          of I as elements of k[x,t].
+RETURN:   a list containing generators of the closure of the desired powers 
+          of I as elements of k[x,t]. 
 "
 {
-  int dblvl=printlevel-voice+2;   // toggles how much data is printed
-                                  // during the procedure
+  int dblvl=printlevel-voice+2;   // toggles how much data is printed 
+                                  // during the procedure  
 
   int j,k,d,computepow;                    // some counters
@@ -431 +439 @@
 
   intmat m[nvars(basering)-1][1];  // an intvec used for jet and maxdeg1
-  intvec tw=m,1;                   // such that t has weight 1 and all
+  intvec tw=m,1;                   // such that t has weight 1 and all 
                                    // other variables have weight 0
 
@@ -453 +461 @@
       }
     }
-  }
+  }  
 
   if (dblvl>0)
@@ -485 +493 @@
     {
       image=images[j]-jet(images[j],k-1,tw);
-      if (image<>0)
-      {
+      if (image<>0)                 
+      {                                        
         image=subst(image/t^k,t,0);
         if (image<>0)
@@ -507 +515 @@
 
   for (k=2;k<=pow;k++)
-  {
+  { 
     for (j=1;j<=(k div 2);j++)
-    {
+    { 
       result[k]=result[k]+result[j]*result[k-j];
     }
   }
-
+  
   return(result);
 }
@@ -520 +528 @@
 
 proc normalI(ideal I, list #)
-"USAGE:   normalI (I [,p[,r]]); I an ideal, p and r optional integers
-COMPUTE:  the integral closure of I, ..., I^p. If p is not given, or p==0,
-          compute the closure of all powers up to the maximum degree in t
-          occurring in the closure of R[It] (so this is the last one that
+"USAGE:    normalI (I [,p[,r]]); I an ideal, p and r optional integers
+COMPUTE:  the integral closure of I, ..., I^p. If p is not given, or p==0, 
+          compute the closure of all powers up to the maximum degree in t 
+          occurring in the closure of R[It] (so this is the last one that 
           is not just the sum/product of the above ones).
-          If r is given and <>1, the check whether the input ideal is
+          If r is given and <>1, the check whether the input ideal is 
           already a radical ideal is omitted.
 RETURN:   a list containing the closure of the desired powers of I as ideals
-          of the basering.
+          of the basering. 
+DISPLAY:  The procedure displays more comments for higher printlevel
+EXAMPLE:  example normalI; shows an example
 "
 {
-  int dblvl=printlevel-voice+2;   // toggles how much data is printed
+  int dblvl=printlevel-voice+2;   // toggles how much data is printed 
                                   // during the procedure
 
@@ -544 +554 @@
     {
       "// Trivial case: I is a principal ideal";
-    }
+    } 
     list result=I;
     if (size(#)>0)
@@ -552 +562 @@
         result=insert(result,I*result[k],k);
       }
-    }
+    } 
     return(result);
   }
@@ -584 +594 @@
           result=insert(result,I*result[k],k);
         }
-      }
+      } 
       return(result);
     }
@@ -595 +605 @@
     "// We start with the Rees Algebra of I:";
   }
-
+  
   list Rees = ReesAlgebra(I);
   def R(1)=Rees[1];
   def Kxt=Rees[2];
   setring R(1);
-
+  
   if (dblvl>0)
   {
@@ -608 +618 @@
     "// Now ClosureRees computes generators for the integral closure";
     "// of R[It] step by step";
-  }
+  } 
 
   // ClosureRees computes fractions in R[x,t] representing the generators
@@ -628 +638 @@
       "//I is integrally closed!";
     }
-
+    
     setring BAS;
     list result=I;
@@ -637 +647 @@
         result=insert(result,I*result[k],k);
       }
-    }
+    } 
     return(result);
   }
-
+    
   // construct the fractions corresponding to the generators of the
-  // closure of I and its powers, depending on # (in fact, they will
+  // closure of I and its powers, depending on # (in fact, they will 
   // not be real fractions, of course). This is done in ClosurePower.
 
@@ -651 +661 @@
   setring BAS;
   list result=fetch(Kxt,result);
-  return(result);
+  return(result);  
 }
 example
 {
+  "EXAMPLE:"; echo=2;
   ring R=0,(x,y),dp;
   ideal I = x2,xy4,y5;