Changeset cb980ab in git

Timestamp:

Jul 9, 2010, 9:36:58 AM (13 years ago)

Author:

Frank Seelisch <seelisch@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

45945a262d8ca4e4d859a9967db621f41ed4c0b6

Parents:

0a4a70481cf50125462e9c1eea5eb085d8ec905a

Message:

check in on behalf of Anne: enhancements for non-global ordering

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

File:

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

Singular/LIB/primdec.lib

@@ -21 +21 @@
     Krick, Logar, Laplagne and Kemper (implementation by Gerhard Pfister and Santiago Laplagne).
     They work in any characteristic.@*
-    Baserings must have a global ordering and no quotient ideal.
+    Some of the algorithms in this library require a global ordering.
+    qrings are not possible as baserings in this library.
+    For local or mixed orderings, most procedures handle the appropriate
+    ring changes internally; otherwise an error message will be printed.
 
 
@@ -50 +53 @@
 LIB "triang.lib";
 LIB "absfact.lib";
+LIB "ring.lib";
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -1888 +1892 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-static proc cleanPrimaryS(list l)
-{
-   int i;
-   list lh;
-   for(i=1;i<=size(l);i++)
-   {
-      l[i][2]=std(l[i][2]);
-      if(deg(l[i][2][1])>0)
-      {
-         lh[size(lh)+1]=l[i];
-      }
-   }
-   return(lh);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-static proc cleanPrimeS(list l)
-{
-   int i;
-   list lh;
-   for(i=1;i<=size(l);i++)
-   {
-      l[i]=std(l[i]);
-      if(deg(l[i][1])>0)
-      {
-         lh[size(lh)+1]=l[i];
-      }
-   }
-   return(lh);
-}
-
-///////////////////////////////////////////////////////////////////////////////
 
 
@@ -2365 +2337 @@
 "
 {
+  if(attrib(basering,"global")!=1)
+  {
+      ERROR(
+      "// Not implemented for this ordering, please change to global ordering."
+      );
+  }
   intvec op ;
   def  P = basering;
-  if(attrib(basering,"global")!=1)
-  {
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     list L=equidim(i,#);
-     setring P;
-     list L=imap(PG,L);
-     L=cleanPrimeS(L);
-     return(L);
-  }
   list eq;
   intvec w;
@@ -2476 +2443 @@
 "
 {
+  if(attrib(basering,"global")!=1)
+  {
+      ERROR(
+      "// Not implemented for this ordering, please change to global ordering."
+      );
+  }
   def  P = basering;
-  if(attrib(basering,"global")!=1)
-  {
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     ideal L=equidimMax(i);
-     setring P;
-     ideal L=imap(PG,L);
-     L=std(L);
-     return(L);
-  }
   ideal eq;
   intvec w;
@@ -3751 +3713 @@
    if((reduce(f,std(h))!=0)||(reduce(diff(f,var(i)),std(h))!=0))
    {
-      ERROR("ERROR in GCD");
+      ERROR("FEHLER IN GCD");
    }
    poly g1=lift(h,f)[1][1];    //  f/h
@@ -3882 +3844 @@
 "
 {
+   if(attrib(basering,"global")!=1)
+   {
+      ERROR(
+      "// Not implemented for this ordering, please change to global ordering."
+      );
+   }
    if((char(basering)<100)&&(char(basering)!=0))
    {
       "WARNING: The characteristic is too small, the result may be wrong";
    }
-   if(attrib(basering,"global")!=1)
-   {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     ideal L=radicalEHV(i);
-     setring P;
-     ideal L=imap(PG,L);
-     L=std(L);
-     return(L);
-   }
-
    ideal J,I,I0,radI0,L,radI1,I2,radI2;
    int l,n;
@@ -4399 +4354 @@
   if((choose<0) or (choose>3))
   {
-    ERROR("<int> must be 0 or 1 or 2 or 3");
+    ERROR("ERROR: <int> must be 0 or 1 or 2 or 3");
   }
   option(notWarnSB);
@@ -5149 +5104 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc primdecGTZ(ideal i)
+proc primdecGTZ(ideal i, list #)
 "USAGE:   primdecGTZ(i); i ideal
 RETURN:  a list pr of primary ideals and their associated primes:
@@ -5156 +5111 @@
    pr[i][2]   the i-th prime component.
 @end format
-NOTE:    Algorithm of Gianni/Trager/Zacharias.
-         Designed for characteristic 0, works also in char k > 0, if it
-         terminates (may result in an infinite loop in small characteristic!)
+NOTE:    - Algorithm of Gianni/Trager/Zacharias.
+         - Designed for characteristic 0, works also in char k > 0, if it
+           terminates (may result in an infinite loop in small characteristic!)
+         - For local orderings, the result is considered in the localization 
+           of the polynomial ring, not in the power series ring
+         - For local and mixed orderings, the decomposition in the 
+           corresponding global ring is returned if the string 'global'
+           is specified as second argument
 EXAMPLE: example primdecGTZ; shows an example
 "
 {
+   if(size(#)>0)
+   {
+      int keep_comp=1;
+   }
    if(attrib(basering,"global")!=1)
    {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     list L=primdecGTZ(i);
-     setring P;
-     list L=imap(PG,L);
-     L=cleanPrimaryS(L);
-     return(L);
+// algorithms only work in global case!
+// pass to appropriate global ring
+      def r=basering;
+      def s=changeord("dp");
+      setring s;
+      ideal i=imap(r,i);
+// decompose and go back 
+      list li=primdecGTZ(i);
+      setring r;
+      def li=imap(s,li);
+// clean up
+      if(!defined(keep_comp))
+      {
+         for(int k=size(li);k>=1;k--)
+         {
+            if(mindeg(std(lead(li[k][2]))[1])==0)
+            { 
+// 1 contained in ideal, i.e. component does not meet origin in local ordering
+               li=delete(li,k);
+            }
+         }
+      }
+      return(li);
    }
+
    if(minpoly!=0)
    {
       return(algeDeco(i,0));
       ERROR(
-      "Not implemented yet for algebraic extensions.Simulate the ring extension by adding the minpoly to the ideal"
+      "// Not implemented yet for algebraic extensions.Simulate the ring extension by adding the minpoly to the ideal"
       );
    }
@@ -5193 +5172 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-proc absPrimdecGTZ(ideal I)
+proc absPrimdecGTZ(ideal I, list #)
 "USAGE:   absPrimdecGTZ(I); I ideal
 ASSUME:  Ground field has characteristic 0.
-RETURN:  a ring containing two lists: @code{absolute_primes} (the absolute
-         prime components of I) and @code{primary_decomp} (the output of
-         @code{primdecGTZ(I)}).
+RETURN:  a ring containing two lists: @code{absolute_primes}, the absolute
+         prime components of I, and @code{primary_decomp}, the output of
+         @code{primdecGTZ(I)}.
          The list absolute_primes has to be interpreted as follows:
          each entry describes a class of conjugated absolute primes,
@@ -5208 +5187 @@
          polynomial of a minimal finite field extension over which the
          absolute prime component is defined.
+         For local orderings, the result is considered in the localization 
+         of the polynomial ring, not in the power series ring.
+         For local and mixed orderings, the decomposition in the 
+         corresponding global ring is returned if the string 'global'
+         is specified as second argument
 NOTE:    Algorithm of Gianni/Trager/Zacharias combined with the
          @code{absFactorize} command.
@@ -5220 +5204 @@
   }
 
+  if(size(#)>0)
+  {
+     int keep_comp=1;
+  }
+
   if(attrib(basering,"global")!=1)
   {
-    ERROR(
-      "Not implemented for this ordering, please change to global ordering."
-    );
+// algorithm automatically passes to the global case
+// hence prepare to go back to an appropriate new ring
+      def r=basering;
+      ideal max_of_r=maxideal(1);
+      def s=changeord("dp");
+      setring s;
+      def I=imap(r,I);
+      def S=absPrimdecGTZ(I);
+      setring S;
+      ring r1=char(basering),var(nvars(r)+1),dp;
+      def rS=r+r1;
+// move objects to appropriate ring and clean up
+      setring rS;
+      def max_of_r=imap(r,max_of_r);
+      attrib(max_of_r,"isSB",1);
+      def absolute_primes=imap(S,absolute_primes);
+      def primary_decomp=imap(S,primary_decomp);
+      if(!defined(keep_comp))
+      {
+         ideal tempid;
+         for(int k=size(absolute_primes);k>=1;k--)
+         {
+            tempid=absolute_primes[k][1];
+            tempid[1]=0;                  // ignore minimal polynomial
+            if(size(reduce(lead(tempid),max_of_r))!=0)
+            { 
+// 1 contained in ideal, i.e. component does not meet origin in local ordering
+               absolute_primes=delete(absolute_primes,k);
+            }
+         }      
+         for(k=size(primary_decomp);k>=1;k--)
+         {
+            if(mindeg(std(lead(primary_decomp[k][2]))[1])==0)
+            { 
+// 1 contained in ideal, i.e. component does not meet origin in local ordering
+               primary_decomp=delete(primary_decomp,k);
+            }
+         }
+         kill tempid;
+      }
+      export(primary_decomp);
+      export(absolute_primes);
+      return(rS);
   }
   if(minpoly!=0)
@@ -5230 +5259 @@
     //return(algeDeco(i,0));
     ERROR(
-      "Not implemented yet for algebraic extensions.Simulate the ring extension by adding the minpoly to the ideal"
+      "// Not implemented yet for algebraic extensions.Simulate the ring extension by adding the minpoly to the ideal"
     );
   }
@@ -5289 +5318 @@
     primary_decomp[i]=list(L[i][1],L[i][2]);
   }
-  for(ii=1;ii<=size(absolute_primes);ii++)
-  {
-     absolute_primes[ii][1]=interred(absolute_primes[ii][1]);
-  }
   export(primary_decomp);
   export(absolute_primes);
   setring R;
-dbprint( printlevel-voice+3,"
-// def S = absPrimdecGTZ(i); creates a ring,
-// which comes with two lists:
-// absolute_primes -- the absolute prime components,
-// and primary_decomp -- the primary and prime
-// components over the current basering).
-// Type setring S; absolute_primes;
-// to access the data.
-");
+  dbprint( printlevel-voice+3,"
+// 'absPrimdecGTZ' created a ring, in which two lists absolute_primes (the
+// absolute prime components) and primary_decomp (the primary and prime
+// components over the current basering) are stored.
+// To access the list of absolute prime components, type (if the name S was
+// assigned to the return value):
+        setring S; absolute_primes; ");
+
   return(Rz);
 }
@@ -5334 +5358 @@
    if c=3,  minAssGTZ and facstd are used.
 @end format
+         For local orderings, the result is considered in the localization 
+         of the polynomial ring, not in the power series ring.
+         For local and mixed orderings, the decomposition in the 
+         corresponding global ring is returned if the string 'global'
+         is specified as third argument 
 EXAMPLE: example primdecSY; shows an example
 "
 {
+   if(size(#)>1)
+   {
+      int keep_comp=1;
+   }
    if(attrib(basering,"global")!=1)
    {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     list L=primdecSY(i,#);
-     setring P;
-     list L=imap(PG,L);
-     L=cleanPrimaryS(L);
-     return(L);
+// algorithms only work in global case!
+// pass to appropriate global ring
+      def r=basering;
+      def s=changeord("dp");
+      setring s;
+      ideal i=imap(r,i);
+// decompose and go back 
+      list li=primdecSY(i);
+      setring r;
+      def li=imap(s,li);
+// clean up
+      if(!defined(keep_comp))
+      {
+         for(int k=size(li);k>=1;k--)
+         { 
+            if(mindeg(std(lead(li[k][2]))[1])==0)
+            { 
+// 1 contained in ideal, i.e. component does not meet origin in local ordering
+               li=delete(li,k);
+            }
+         }
+      }
+      return(li);
    }
-
    i=simplify(i,2);
    if ((i[1]==0)||(i[1]==1))
@@ -5356 +5402 @@
      return(list(L));
    }
+
    if(minpoly!=0)
    {
       return(algeDeco(i,1));
    }
-   if (size(#)==1)
+   if (size(#)!=0)
    { return(prim_dec(i,#[1])); }
    else
@@ -5384 +5431 @@
 
 RETURN:  a list, the minimal associated prime ideals of I.
-NOTE:    Designed for characteristic 0, works also in char k > 0 based
-         on an algorithm of Yokoyama
+NOTE:    - Designed for characteristic 0, works also in char k > 0 based
+           on an algorithm of Yokoyama
+         - For local orderings, the result is considered in the localization 
+           of the polynomial ring, not in the power series ring
+         - For local and mixed orderings, the decomposition in the 
+           corresponding global ring is returned if the string 'global'
+           is specified as second argument
 EXAMPLE: example minAssGTZ; shows an example
 "
 {
+   if(size(#)>0)
+   {
+      int keep_comp=1;
+   }
+
+  if(attrib(basering,"global")!=1)
+  {
+  // algorithms only work in global case!
+// pass to appropriate global ring
+      def r=basering;
+      def s=changeord("dp");
+      setring s;
+      ideal i=imap(r,i);
+// decompose and go back 
+      list li=minAssGTZ(i);
+      setring r;
+      def li=imap(s,li);
+// clean up
+      if(!defined(keep_comp))
+      {
+         for(int k=size(li);k>=1;k--)
+         {
+            if(mindeg(std(lead(li[k]))[1])==0)
+            { 
+// 1 contained in ideal, i.e. component does not meet origin in local ordering
+               li=delete(li,k);
+            }
+         }
+      }
+      return(li);
+  }
+
   int j;
   string algorithm;
@@ -5426 +5510 @@
       }
     }
-  }
-  if(attrib(basering,"global")!=1)
-  {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     list L=minAssGTZ(i,#);
-     setring P;
-     list L=imap(PG,L);
-     L=cleanPrimeS(L);
-     return(L);
   }
 
@@ -5465 +5537 @@
          Otherwise, the system tries to find an optimal ordering,
          which in some cases may considerably speed up the algorithm. @*
+         For local orderings, the result is considered in the localization 
+         of the polynomial ring, not in the power series ring
+         For local and mixed orderings, the decomposition in the 
+         corresponding global ring is returned if the string 'global'
+         is specified as third argument
 EXAMPLE: example minAssChar; shows an example
 "
 {
+   if(size(#)>1)
+   {
+      int keep_comp=1;
+   }
    if(attrib(basering,"global")!=1)
    {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     list L=minAssChar(i,#);
-     setring P;
-     list L=imap(PG,L);
-     L=cleanPrimeS(L);
-     return(L);
+// algorithms only work in global case!
+// pass to appropriate global ring
+      def r=basering;
+      def s=changeord("dp");
+      setring s;
+      ideal i=imap(r,i);
+// decompose and go back 
+      list li=minAssChar(i);
+      setring r;
+      def li=imap(s,li);
+// clean up
+      if(!defined(keep_comp))
+      {
+         for(int k=size(li);k>=1;k--)
+         {
+            if(mindeg(std(lead(li[k]))[1])==0)
+            { 
+// 1 contained in ideal, i.e. component does not meet origin in local ordering
+               li=delete(li,k);
+            }
+         }
+      }
+      return(li);
    }
-
-   if (size(#)==1)
+   if (size(#)>0)
    { return(min_ass_prim_charsets(i,#[1])); }
    else
@@ -5504 +5598 @@
 "
 {
-   if(attrib(basering,"global")!=1)
-   {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     ideal L=equiRadical(i);
-     setring P;
-     ideal L=imap(PG,L);
-     L=std(L);
-     return(L);
-   }
-
+  if(attrib(basering,"global")!=1)
+  {
+     ERROR(
+     "// Not implemented for this ordering, please change to global ordering."
+     );
+  }
   return(radical(i, 1));
 }
@@ -5545 +5632 @@
 "
 {
-   dbprint(printlevel - voice, "Radical, version 2006.05.08");
-   if(attrib(basering,"global")!=1)
-   {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     ideal L=radical(i,#);
-     setring P;
-     ideal L=imap(PG,L);
-     L=std(L);
-     return(L);
-   }
-
+  dbprint(printlevel - voice, "Radical, version 2006.05.08");
+  if(attrib(basering,"global")!=1)
+  {
+// algorithms only work in global case!
+// pass to appropriate global ring
+      def r=basering;
+      def s=changeord("dp");
+      setring s;
+      ideal i=imap(r,i);
+// compute radical and go back 
+      def j=radical(i);
+      setring r;
+      def j=imap(s,j);
+      return(j);
+  }
   if(size(i) == 0){return(ideal(0));}
   int j;
@@ -6325 +6413 @@
   if(attrib(basering,"global")!=1)
   {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     list L=prepareAss(i);
-     setring P;
-     list L=imap(PG,L);
-     L=cleanPrimeS(L);
-     return(L);
-  }
-
+      ERROR(
+      "// Not implemented for this ordering, please change to global ordering."
+      );
+  }
   ideal j=std(i);
   int cod=nvars(basering)-dim(j);
@@ -6378 +6459 @@
 "
 {
-   if(attrib(basering,"global")!=1)
-   {
-     def P=basering;
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(P,i);
-     ideal L=equidimMaxEHV(i);
-     setring P;
-     ideal L=imap(PG,L);
-     L=std(L);
-     return(L);
-   }
-
+  if(attrib(basering,"global")!=1)
+  {
+      ERROR(
+      "// Not implemented for this ordering, please change to global ordering."
+      );
+  }
   ideal j=groebner(i);
   int cod=nvars(basering)-dim(j);
@@ -6453 +6527 @@
 "
 {
+  if(attrib(basering,"global")!=1)
+  {
+    ERROR(
+    "// Not implemented for this ordering, please change to global ordering."
+    );
+  }
   def R=basering;
-  if(attrib(basering,"global")!=1)
-  {
-     def PG=changeord("dp");
-     setring PG;
-     ideal i=imap(R,I);
-     list L=zerodec(i);
-     setring R;
-     list L=imap(PG,L);
-     L=cleanPrimeS(L);
-     return(L);
-  }
-
   poly q;
   int j,time;