Changeset 768b28 in git

Timestamp:

Feb 3, 2010, 10:37:45 AM (13 years ago)

Author:

Frank Seelisch <seelisch@…>

Branches:

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

Children:

538d63bfc3ca276e2733bf749ab86a1685ec5dad

Parents:

f679897a09a02b4b0b17aed9982a4f6c8356c1d3

Message:

changes by Anne Fruehbis-Krueger

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

File:

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

Singular/LIB/primdec.lib

@@ -5 +5 @@
 LIBRARY: primdec.lib   Primary Decomposition and Radical of Ideals
 AUTHORS:  Gerhard Pfister, pfister@mathematik.uni-kl.de (GTZ)@*
-          Wolfram Decker, decker@mathematik.uni-kl.de   (SY)@*
+          Wolfram Decker, decker@math.uni-sb.de         (SY)@*
           Hans Schoenemann, hannes@mathematik.uni-kl.de (SY)@*
           Santiago Laplagne, slaplagn@dm.uba.ar         (GTZ)
@@ -50 +50 @@
 LIB "triang.lib";
 LIB "absfact.lib";
+LIB "ring.lib";
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ -5100 +5101 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-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:
@@ -5107 +5108 @@
    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)
    {
-      ERROR(
-      "// Not implemented for this ordering, please change to global ordering."
-      );
+// 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)
    {
@@ -5138 +5169 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-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,
@@ -5153 +5184 @@
          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.
@@ -5165 +5201 @@
   }
 
+  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)
@@ -5274 +5355 @@
    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)
    {
-      ERROR(
-      "// Not implemented for this ordering, please change to global ordering."
-      );
+// 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);
@@ -5289 +5399 @@
      return(list(L));
    }
+
    if(minpoly!=0)
    {
       return(algeDeco(i,1));
    }
-   if (size(#)==1)
+   if (size(#)!=0)
    { return(prim_dec(i,#[1])); }
    else
@@ -5317 +5428 @@
 
 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;
@@ -5361 +5509 @@
   }
 
-  if(attrib(basering,"global")!=1)
-  {
-    ERROR(
-      "// Not implemented for this ordering, please change to global ordering."
-    );
-  }
   if(minpoly!=0)
   {
@@ -5392 +5534 @@
          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)
    {
-      ERROR(
-      "// Not implemented for this ordering, please change to global ordering."
-      );
+// 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
@@ -5461 +5632 @@
   if(attrib(basering,"global")!=1)
   {
-    ERROR(
-     "// Not implemented for this ordering, please change to global ordering."
-    );
+// 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));}