Changeset e1fdcd in git for Singular/LIB/normal.lib

Timestamp:

May 20, 2010, 6:03:06 PM (14 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

dd4942c513f746e8c0cbbd433a4310c9fbb756ea

Parents:

c12222e2ab738f967d4dd4a6e28afd75114c4cf7

Message:

extended version for intBasis.lib

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

File:

• Singular/LIB/normal.lib (modified) (25 diffs)

Singular/LIB/normal.lib

@@ -64 +64 @@
          - \"withDelta\" (or \"wd\") -> returns also the delta invariants.@*
          If the optional parameter choose is not given or empty, only
-         \"equidim\" but no other option is used.
+         \"equidim\" but no other option is used.@*
+         The following options can be used when the ring has two variables.
+         They are needed for computing integral basis.@*
+         - \"var1\" -> uses a polynomial in the first variable as conductor.@*
+         - \"var2\" -> uses a polynomial in the second variable as conductor.@*
 ASSUME:  The ideal must be radical, for non-radical ideals the output may
          be wrong (id=radical(id); makes id radical). However, when using the
@@ -125 +129 @@
 "
 {
-   intvec opt = option(get);     // Save current options
+  intvec opt = option(get);     // Save current options
 
   int i,j;
@@ -138 +142 @@
   int nvar = nvars(basering);
   int chara  = char(basering);
-  list result;
+  int conduOption;   // Method for choosing the conductor
+  list result, resultNew;
   list keepresult;
   list ringStruc;
@@ -196 +201 @@
     }
   }
+
+  conduOption = 0;     // The default is the smallest degree polynomial
+  if ( find(method,"var1") )
+  {conduOption = 1;}
+  if ( find(method,"var2") )
+  {conduOption = 2;}
+
 
   kill #;
@@ -238 +250 @@
     def ROut = ring(lR);
     setring ROut;
-    ideal norid = 0;
+    ideal norid = fetch(origR, id);
     ideal normap = maxideal(1);
     export norid;
@@ -245 +257 @@
     if(withDelta)
     {
-      result = list(list(ideal(1), poly(1), ROut), 0);
+      result = list(list(ROut), list(ideal(1)), list(intvec(0), 0));
     }
     else
     {
-      result = list(list(ideal(1), poly(1), ROut));
-    }
+      result = list(list(ROut), list(ideal(1)));
+    }
+    sp = 1;      // number of rings in the output
+    option(set, opt);
+    normalOutputText(dbg, withDelta, sp);
     return(result);
   }
-
 //------------------------ preliminary decomposition-----------------------
   list prim;
@@ -330 +344 @@
       }
       printlevel = printlevel + 1;
-      norComp = normalM(prim[i], decomp, withDelta);
+      norComp = normalM(prim[i], decomp, withDelta, conduOption);
       printlevel = printlevel - 1;
       for(j = 1; j <= size(norComp); j++)
@@ -434 +448 @@
     }
   }
-  list resultNew;
-
   if(withDelta)
   {
@@ -444 +456 @@
     resultNew = list(RL, MG);
   }
-
   sp = size(RL);              //RL = list of rings
+
   option(set, opt);
-
+  normalOutputText(dbg, withDelta, sp);
+  return(resultNew);
+}
+
+example
+{ "EXAMPLE:";
+  printlevel = printlevel+1;
+  echo = 2;
+  ring s = 0,(x,y),dp;
+  ideal i = (x2-y3)*(x2+y2)*x;
+  list nor = normal(i, "withDelta", "prim");
+  nor;
+
+  // 2 branches have delta = 1, and 1 branch has delta = 0
+  // the total delta invariant is 13
+
+  def R2 = nor[1][2];  setring R2;
+  norid; normap;
+
+  echo = 0;
+  printlevel = printlevel-1;
+  pause("   hit return to continue"); echo=2;
+
+  ring r = 2,(x,y,z),dp;
+  ideal i = z3-xy4;
+  list nor = normal(i, "withDelta", "prim");  nor;
+  // the delta invariant is infinite
+  // xy2z/z2 and xy3/z2 generate the integral closure of r/i as r/i-module
+  // in its quotient field Quot(r/i)
+
+  // the normalization as affine algebra over the ground field:
+  def R = nor[1][1]; setring R;
+  norid; normap;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Prints the output text in proc normal.
+//
+static proc normalOutputText(int dbg, int withDelta, int sp)
+// int dbg: printlevel
+// int withDelta: output contains information about the delta invariant
+// int sp: number of output rings.
+{
   if ( dbg >= 0 )
   {
@@ -484 +538 @@
     }
   }
-  return(resultNew);
 }
 
-example
-{ "EXAMPLE:";
-  printlevel = printlevel+1;
-  echo = 2;
-  ring s = 0,(x,y),dp;
-  ideal i = (x2-y3)*(x2+y2)*x;
-  list nor = normal(i, "withDelta", "prim");
-  nor;
-
-  // 2 branches have delta = 1, and 1 branch has delta = 0
-  // the total delta invariant is 13
-
-  def R2 = nor[1][2];  setring R2;
-  norid; normap;
-
-  echo = 0;
-  printlevel = printlevel-1;
-  pause("   hit return to continue"); echo=2;
-
-  ring r = 2,(x,y,z),dp;
-  ideal i = z3-xy4;
-  list nor = normal(i, "withDelta", "prim");  nor;
-  // the delta invariant is infinite
-  // xy2z/z2 and xy3/z2 generate the integral closure of r/i as r/i-module
-  // in its quotient field Quot(r/i)
-
-  // the normalization as affine algebra over the ground field:
-  def R = nor[1][1]; setring R;
-  norid; normap;
-}
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -3523 +3546 @@
            if(noRed == 0){
              resu = list(computeRing(II,prim[i])) + resu;
-           } else {
+           }
+           else
+           {
              resu = list(computeRing(II,prim[i], "noRed")) + resu;
            }
@@ -3932 +3957 @@
       setring R;
       return(R1);
-    } else {
+    }
+    else
+    {
       list L = substpartSpecial(norid,normap);
       def lastRing = L[1];
@@ -4041 +4068 @@
         A = lift(pf, ff, u);
         Quad = Quad,ideal(newT[jj-1]*newT[ii-1] * u[1, 1]- T*A);
-      } else {
+      }
+      else
+      {
         A = lift(pf,ff);              // ff lin. comb. of elts of pf mod I
         Quad = Quad,ideal(newT[jj-1]*newT[ii-1] - T*A);
@@ -4083 +4112 @@
     }
     return(lastRing);
-  } else {
+  }
+  else
+  {
     ideal norid = endid;
     ideal normap = endphi;
@@ -4099 +4130 @@
 //                From here: subprocedures for normal
 
-static proc normalM(ideal I, int decomp, int withDelta){
+static proc normalM(ideal I, int decomp, int withDelta, int conduOption){
 // Computes the normalization of a ring R / I using the module structure as far
 // as possible.
@@ -4137 +4168 @@
 // decomp = 3 (meaning that the ideal is prime).
 
+// conduOption = 0      -> Uses the smallest degree polynomial
+// conduOption = i > 0  -> Uses a polynomial in the i-th variable
+
   option("redSB");
   option("returnSB");
@@ -4153 +4187 @@
     I = IM[1];
     ideal IMin = IM[2];   // A minimal set of generators in the groebner basis.
-  } else {
+  }
+  else
+  {
     // The minimal set of generators is not computed by mstd for
     // non-global orderings.
@@ -4191 +4227 @@
     if(withDelta){
       list output = ideal(1), poly(1), ROut, 0;
-    } else {
+    }
+    else
+    {
       list output = ideal(1), poly(1), ROut;
     }
@@ -4199 +4237 @@
 
   // -------------------- election of the conductor -------------------------
-  poly condu = getSmallest(J);   // Choses the polynomial of smallest degree
-                                 // of J as universal denominator.
+  if(conduOption == 0){
+    poly condu = getSmallest(J);   // Choses the polynomial of smallest degree
+                                   // of J as universal denominator.
+  }
+  else
+  {
+    poly condu = getOnevar(J, conduOption);
+  }
   if(dbg >= 1){
     "";
@@ -4223 +4267 @@
       // I = I1 \cap I2
       printlevel = printlevel + 1;
-      list nor1 = normalM(Id1, decomp, withDelta)[1];
-      list nor2 = normalM(Id2, decomp, withDelta)[1];
+      list nor1 = normalM(Id1, decomp, withDelta, conduOption)[1];
+      list nor2 = normalM(Id2, decomp, withDelta, conduOption)[1];
       printlevel = printlevel - 1;
       return(list(nor1, nor2));
@@ -4249 +4293 @@
     if(locAtZero(J)){
       J = maxideal(1);
-    } else {
+    }
+    else
+    {
       J = radical(J);
     }
-  } else {
+  }
+  else
+  {
     // We change to global dp ordering.
     list rl = ringlist(R);
@@ -4284 +4332 @@
   J = fetch(R, J);
   J = interred(J);
-  poly D = getSmallest(J);    // Chooses the polynomial of smallest degree as
-                              // non-zerodivisor.
+  if(conduOption == 0){
+    poly D = getSmallest(J);    // Chooses the polynomial of smallest degree as
+                                // non-zerodivisor.
+  }
+  else
+  {
+    poly D = getOnevar(J, conduOption);
+  }
   if(dbg >= 1){
     "The non zero divisor is ", D;
@@ -4311 +4365 @@
       printlevel = printlevel + 1;
 
-      list nor1 = normalM(Id1, decomp, withDelta)[1];
-      list nor2 = normalM(Id2, decomp, withDelta)[1];
+      list nor1 = normalM(Id1, decomp, withDelta, conduOption)[1];
+      list nor2 = normalM(Id2, decomp, withDelta, conduOption)[1];
       printlevel = printlevel - 1;
       return(list(nor1, nor2));
@@ -4325 +4379 @@
   J = fetch(Q, J);
   printlevel = printlevel + 1;
-  list result = normalMEqui(I, J, condu, D, withDelta);
+  list result = normalMEqui(I, J, condu, D, withDelta, conduOption);
   printlevel = printlevel - 1;
   return(list(result));
@@ -4543 +4597 @@
   }
   return(newU);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+//WARNING - elim is not working here!! Check!!
+//It is now replace by computing an eliminating groebner basis.
+static proc getOnevar(ideal J, int vari)
+{
+// Computes the polynomial of smallest degree of J.
+// If there are more than one, it chooses the one with smallest number
+// of monomials.
+  def R = basering;
+  ring RR = 0, (var(3-vari), var(vari)), lp;
+  ideal J = imap(R, J);
+  J = groebner(J);
+  poly D = J[1];
+  setring R;
+  poly D = imap(RR, D);
+  return(D);
 }