Changeset a6d6356 in git

Timestamp:

Jan 21, 2015, 6:25:42 PM (9 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

584649e7d56725619ab0a2ed50ec5fd4f180e711

Parents:

0cf4e11fc56e44e8ce67684afe4a45479455ea583176e6e1402d3ad808ee0b00f1589716317afe8f

Message:

Merge pull request #638 from surface-smoothers/fix.unit.and.zero.primary.decomposition

fixed some bugs for zero and patch for unit ideal decomposition
fix for this merge follows.

Files:

• Singular/LIB/gradedModules.lib (modified) (20 diffs)
• Singular/LIB/primdec.lib (modified) (119 diffs)
• Singular/LIB/ring.lib (modified) (3 diffs)
• Singular/LIB/rinvar.lib (modified) (3 diffs)
• Singular/LIB/sagbi.lib (modified) (2 diffs)
• Singular/LIB/solve.lib (modified) (5 diffs)
• Singular/subexpr.cc (modified) (1 diff)
• Tst/Short.lst (modified) (1 diff)
• Tst/Short/bug_529.res.gz.uu (modified) (1 diff)
• Tst/Short/bug_529.stat (modified) (1 diff)
• Tst/Short/bug_tr686.res.gz.uu (added)
• Tst/Short/bug_tr686.stat (added)
• Tst/Short/bug_tr686.tst (added)
• Tst/Short/ok_s.lst (modified) (1 diff)
• Tst/Short/test_unit_ideal_decomposition.res.gz.uu (added)
• Tst/Short/test_unit_ideal_decomposition.stat (added)
• Tst/Short/test_unit_ideal_decomposition.tst (added)
• Tst/Short/test_zero_ideal_decomposition.res.gz.uu (added)
• Tst/Short/test_zero_ideal_decomposition.tst (added)
• doc/general.doc (modified) (previous)
• libpolys/coeffs/longrat.cc (modified) (1 diff)
• libpolys/coeffs/rintegers.cc (modified) (1 diff)
• libpolys/polys/clapsing.cc (modified) (3 diffs)

Singular/LIB/gradedModules.lib

@@ -5 +5 @@
 LIBRARY: gradedModules.lib     Operations with graded modules/matrices/resolutions
 AUTHOR:  Oleksandr Motsak <U@D>, where U={motsak}, D={mathematik.uni-kl.de}
+         Hanieh Keneshlou <hkeneshlou@yahoo.com>
 KEYWORDS: graded modules, graded homomorphisms, syzygies
 OVERVIEW:
     @* The library contains several procedures for operations with graded modules/matrices/resolutions
-
+    @* TODO!
 NOTE:        
-    @* try @code{example TestGRRes;} from examples
+    @* try @code{example TestGRRes; example grsum; } from examples
 PROCEDURES:
-        
+
+    grzero()        presentation of basering(0)^1
+    grobj(M,w)      construct a graded module object 
+    grshift(M,d)    shift graded module M by d
+    grtwist(r,d)    presentation of basering(d)^r
+    grsum(M,N)      direct sum of two graded modules M \oplus N
+    grpower(M,p)    direct p-th power of graded module M
     grview(M)       view the graded structure of M
     grdeg(M)        compute graded degrees of M    
@@ -22 +29 @@
 @*
 [MO]   Motsak, O.: Non-commutative Computer Algebra with applications: Graded commutative algebra and related
-       structures in Singular with applications, Ph.D. thesis, TU Kaiserslautern, 2010?
+       structures in Singular with applications, Ph.D. thesis, TU Kaiserslautern, 2010 TODO!?
 ";
-
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -35 +41 @@
 static proc pad(int m, string s, string c){ string r = s; while( size(r) < m ){ r = c + r; } return(r); }
 static proc mstring( int m, string c){ if( m < 0 ) { return (c); }; return (string(m)); }
+static proc zstring( int m, int b, string c){ if(b) { return (c); }; return (string(m)); }
 // view helper
-static proc draw ( intmat D, int d )
+static proc draw ( intmat D, intvec zc, int d )
 {
 //  print(D); return ();
@@ -48 +55 @@
   {
     head = head + pad(max, string(D[1 , c]), " ") + " ";
-    foot = foot + pad(max, string(D[nr, c]), " ") + " ";
+    foot = foot + pad(max, zstring(D[nr, c], zc[c - d], "?"), " ") + " ";
   }
   // last head/foot enties:
-  head = head + pad(max, string(D[1 , nc-d]), " ");
-  foot = foot + pad(max, string(D[nr, nc-d]), " ");
+  head = head + pad(max, string(D[1 , c]), " ");
+  foot = foot + pad(max, zstring(D[nr, c], zc[c-d], "?"), " ");
   // head/foot dash lines:
   string dash  = repeat( (max + 1) * (nc - 2*d) , "-");
@@ -77 +84 @@
 "
 {
-  if( size(N) == 0 ) { return (); }
+//  if( size(N) == 0 ) { return (); }
   
   if( typeof( N ) == "list" )
@@ -102 +109 @@
   
   module L = module(N); L = lead(L); vector v;
-  int m = 1 + nvars(basering); 
+  int m = 1 + nvars(basering);
+  intvec zc = 0:nc;
   for( c = nc; c > 0; c-- )
   {
     D[1, c+d] = c; // top row indeces
     v = L[c];
-    D[nr+2*d, c+d] = deg(v) + gr[ leadexp(v)[m] ]; // bottom row with computed column induced degrees
+    if( v != 0 )
+    {
+      D[nr+2*d, c+d] = deg(v) + gr[ leadexp(v)[m] ]; // bottom row with computed column induced degrees
+    } else
+    {
+//      D[nr+2*d, c+d] = 0; // TODO: 0/-1 is valid :(
+      zc[c] = 1; 
+    }
   }
   
@@ -115 +130 @@
     for( c = nc; c > 0; c-- )
     {
-      D[r+d, c+d] = deg(M[r, c]); // central block with degrees
-//      if( D[r+d, c+d] < 0 ) { D[r+d, c+d] = 0; }
+      D[r+d, c+d] = deg(M[r, c]); // central block with degrees (-1 means zero entry)
     }
     D[r+d, nc+2*d] = r; // right-most block with indeces
   }
-  draw(D, d); // print it nicely!
+  draw(D, zc, d); // print it nicely!
 }
 
@@ -126 +140 @@
 static proc issorted( intvec g, int s )
 {
+  g = s * g; //  "g: ", g;
   int i = size(g);
 
   for(; i > 1; i--)
   {
-    if( s*(g[i] - g[i-1]) < 0 )
+    if( (g[i] - g[i-1]) < 0 )
     {
       return (0);
@@ -144 +159 @@
 "
 {
+  gr = s * gr;
   int m = size(gr);
-
   intvec pivot; 
 
@@ -162 +177 @@
     for(Bn=1; Bn <= (m-Bi); Bn++)
     {
-      D = s*(gr[pivot[Bn]] - gr[pivot[Bn+1]]); // sort gr 
+      D = (gr[pivot[Bn]] - gr[pivot[Bn+1]]); // sort gr 
       P = (D > 0) or ( (D == 0) && ((pivot[Bn]-pivot[Bn+1]) > 0) ); // stability!?
       if(P)
@@ -175 +190 @@
   }
 
-  ASSUME(1, issorted(gr, s));
 
   if( flag && 0 ) // output details in case of non-identical permutation?
   {
     // grades & ordering permutation : gr[pivot] should be sorted:
-    "";
+    "s: ", s;
+    "gr: ", gr;
     "pivot: ",    pivot;
-    "";
-  }
+  }
+
+  ASSUME(1, issorted(intvec(gr[pivot]), 1));
 
   return (pivot);
@@ -217 +233 @@
   def w = attrib(M, "isHomog"); // grading weights?
   ASSUME(0, /* input must be correctly graded! */ nrows(M) == size(w) );   
-  
+
+  if( size(M) == 0 )  {    return (w);  } // TODO???
+
   int m = ncols(M); // m > 0 in Singular!
-  int n = nvars(basering) + 1; // index of mod. column in the leadexp 
+  int n = nvars(basering) + 1; // index of mod. column in the leadexp
 
   module L = lead(M[1..m]); // leading module-terms for input column vectors
-  intvec d = deg(L[1..m]); // their degrees
+  intvec d = deg(L[1..m]); // their degrees  
   intvec c = leadexp(L[1..m])[n]; // their module-components
-  intvec gr = w[c]; // weights
+  
+  w = intvec(-6665, w); // 0?????
+  intvec gr = w[1+c]; // weights
   
   gr = gr + d; // finally we compute their graded degrees
@@ -286 +306 @@
 
   // grades & ordering permutation for N.  d[p] should be sorted!
-
-  def N = module(M[p]);  // reorder the starting ideal/module
-
-  attrib( N, "isHomog", w ); // set the grading
+  
+  def N = grobj(module(M[p]), w);  // reorder the starting ideal/module
 
   d = d[p];
@@ -401 +419 @@
 //      grview(M[i]);
       L[j] = grtranspose(M[i]);
-      if( i > 1 )
+//      grview(L[j]);
+
+      if( (i > 1) && (j > 0) )
       {
-        ASSUME(2, size( module( matrix(L[j+1])*matrix(L[j]) ) ) == 0 );
+//        grview(L[j+1]);
+        ASSUME(2, size( module( matrix(L[j])*matrix(L[j+1]) ) ) == 0 );
       };
 //      grview(L[j]);
@@ -421 +442 @@
  else              { (N,d) = reorder(M, -1); }
 
- kill M; module M = transpose(N);
- attrib( M, "isHomog", -d ); // set the grading
+ kill M; module M = grobj(transpose(N), -d);
 
 // "b";  grview(M);
@@ -429 +449 @@
  // reverse order:
  (N,d) = reorder(M, 1); kill M;
-
-/*
- module M = transpose(N); 
- attrib( M, "isHomog", -d ); // set the grading
-
-// "c";  grview(M);
- 
- kill N,d; module N; intvec d;
- // reverse order:
- (N,d) = reorder(M, -1); kill M;
- module M = transpose(N); 
- attrib( M, "isHomog", -d ); // set the grading
-
-// "d";  grview(M);
- 
- kill N,d; module N; intvec d;
- // reverse order:
- (N,d) = reorder(M, 1);
- 
- kill M;
-*/
 
 // "e"; grview( N );
@@ -506 +505 @@
   if( size(#) > 0 ) { (N,d) = reorder(M, 1, #[1]); }
   else              { (N,d) = reorder(M, 1); }  
-  kill M; module M = transpose(N);
-  attrib( M, "isHomog", -d ); // set the grading
+  kill M; module M = grobj(transpose(N), -d);
 
 // "b";  grview(M);
@@ -515 +513 @@
   (N,d) = reorder(M, -1); kill M;
  
-  module M = transpose(N); 
-  attrib( M, "isHomog", -d ); // set the grading
+  module M = grobj(transpose(N), -d);
 
 // "c";  grview(M);
@@ -561 +558 @@
 }
 example
-{ "EXAMPLE:"; echo = 2; int assumeLevel = 5;
+{ "EXAMPLE:"; echo = 2; 
+  if( defined(assumeLevel) ){ int assumeLevel0 = assumeLevel; } else { int assumeLevel; export(assumeLevel); }  // store the state of aL
+  assumeLevel = 5;
 
   string Name = "castelnuovo"; int @p=31991; ring R = (@p),(x,y,z,u,v), dp;ideal I = 5153xy2-98/23y3-101/51xyz+33/41y2z+99/79xz2+7136yz2-106/111z3+119/53xyu+34/57y2u-77/92xzu+84/73yzu-109/78z2u-27/56xu2+10023yu2+82/103zu2-34/25u3+3/2xyv-68/25y2v+12721xzv+4/63yzv-73/21z2v-7291xuv-91/53yuv-4/79zuv-34/91u2v-122/53xv2+123/70yv2-64/73zv2+44/65uv2+14/31v3,xy2-15202y3+10613xyz+13640y2z-107/103xz2+5292yz2+19/119z3-10042xyu+2770y2u+7957xzu+14008yzu+92/121z2u-92/51xu2+1178yu2+1/117zu2-12726u3+82/101xyv-92/17y2v-107/56xzv+14233yzv+79/28z2v+51/50xuv-31/5yuv+95/91zuv+19/108u2v+12151xv2-69/110yv2+37/89zv2-63/116uv2-88/23v3,-5153x2+37/23xy+8706y2-13160xz+68/115yz+5548z2-22/61xu-113/98yu+11818zu+2114u2-101/97xv+89/22yv-3355zv-113/5uv-5521v2;TestGRRes(Name, 2, I); kill R, Name, @p;  "";
@@ -582 +581 @@
 
   string Name = "rat.d10.g9.quart2"; int @p=31991; ring R = (@p),(x,y,z,u,v), dp;ideal I = x3yu2-48/11x2y2u2-8356xy3u2+35/121y4u2+31/66x3zu2-54/83x2yzu2-61/18xy2zu2+11526y3zu2+7372x2z2u2-91/60xyz2u2-95/97y2z2u2-45/71xz3u2+71/115yz3u2+25/54z4u2-61/102x3u3-12668x2yu3+6653xy2u3+41/54y3u3+87/50x2zu3-5004xyzu3+13924y2zu3+2310xz2u3-93/14yz2u3-2/93z3u3-97/125x2u4-58/11xyu4+46/73y2u4-4417xzu4+60/101yzu4+56/75z2u4-113/118xu5+115/4yu5-40zu5-8554u6-54/83x3yuv-9770x2y2uv-590xy3uv+15/49y4uv+94/69x3zuv+121/105x2yzuv+95/88xy2zuv+3186y3zuv+11/6x2z2uv-44/81xyz2uv+637y2z2uv+109/121xz3uv-33yz3uv-94/115z4uv-49/95x3u2v-11/109x2yu2v+45/113xy2u2v+97/84y3u2v+5257x2zu2v+99/49xyzu2v+12584y2zu2v-4294xz2u2v+1137yz2u2v-58/69z3u2v-4749x2u3v+120/97xyu3v-31/103y2u3v+62/97xzu3v-107/74yzu3v+53/59z2u3v+91/33xu4v+1291yu4v+23/34zu4v+58/77u5v+16/17x3yv2-750x2y2v2+86/89xy3v2+123/46y4v2+53/123x3zv2-61/99x2yzv2+12389xy2zv2+10419y3zv2+43/11x2z2v2-146xyz2v2-116/51y2z2v2+13/62xz3v2-5524yz3v2-111/118z4v2-56/55x3uv2-3038x2yuv2+14/27xy2uv2-43/64y3uv2+3385x2zuv2+25/11xyzuv2+92/41y2zuv2+28/113xz2uv2-2049yz2uv2+89/37z3uv2-13094x2u2v2-2774xyu2v2+15474y2u2v2-15791xzu2v2-71/116yzu2v2+77/41z2u2v2-83/68xu3v2-33/106yu3v2+71/37zu3v2-41/17u4v2+12052x3v3+1906x2yv3+13825xy2v3+80/7y3v3-125/96x2zv3-9661xyzv3+85/116y2zv3-72/91xz2v3+13/112yz2v3-126/97z3v3-1637x2uv3+34/103xyuv3+3844y2uv3+77/10xzuv3+6359yzuv3-11185z2uv3-124/121xu2v3+66/91yu2v3-14636zu2v3-1051u3v3+9/64x2v4-12924xyv4-119/41y2v4+74/23xzv4+1622yzv4+73/37z2v4-60/101xuv4+111/22yuv4-45/124zuv4+59/37u2v4-66/37xv5-71/99yv5+12409zv5-113/64uv5-5267v6,-x4y-22/79x3y2-125/42x2y3-116/7xy4+98/111y5-31/66x4z-118/75x3yz+110/93x2y2z-43/92xy3z-788y4z-7372x3z2-2701x2yz2-67/124xy2z2-117/62y3z2+45/71x2z3-8396xyz3-10343y2z3-25/54xz4+30/59yz4+61/102x4u+11736x3yu+12726x2y2u+41/118xy3u-15832y4u-87/50x3zu-130x2yzu+41/8xy2zu-10300y3zu-2310x2z2u-101/5xyz2u+6205y2z2u+2/93xz3u+8679yz3u+97/125x3u2-43/37x2yu2-39/80xy2u2+12139y3u2+4417x2zu2+4294xyzu2+11/58y2zu2-56/75xz2u2+8338yz2u2+113/118x2u3-10190xyu3-37/16y2u3+40xzu3+74/23yzu3+8554xu4+115/22yu4-39/79x4v+61/72x3yv+8048x2y2v-9201xy3v+16/121y4v+113/93x3zv+109/75x2yzv+12700xy2zv-10607y3zv+50/11x2z2v+1223xyz2v-103/79y2z2v-123/58xz3v+31/26yz3v-15/122z4v+122/25x3uv-99/17x2yuv+1723xy2uv-38/121y3uv+11016x2zuv-25/102xyzuv-14970y2zuv-61/6xz2uv-14981yz2uv+15900z3uv+3268x2u2v-75/19xyu2v-1436y2u2v-1764xzu2v-57/41yzu2v+12741z2u2v-14615xu3v+119/61yu3v-115/119zu3v+10501u4v-8502x3v2-51/76x2yv2-6281xy2v2+17/49y3v2-106/7x2zv2+63/101xyzv2-27/95y2zv2-1606xz2v2+9245yz2v2+1912z3v2+11155x2uv2+223xyuv2-13/18y2uv2+110/43xzuv2+76/81yzuv2-6291z2uv2+1400xu2v2-95/23yu2v2-9701zu2v2+106/105u3v2+72/47x2v3-13118xyv3+14409y2v3+37/86xzv3+44/69yzv3-325z2v3+113/71xuv3+16/81yuv3+6/19zuv3-119/39u2v3-89/9xv4+72/53yv4+112/55zv4-8587uv4-6604v5,-x3y2+48/11x2y3+8356xy4-35/121y5-12750x3yz+100/111x2y2z+45/74xy3z+99/74y4z-6/7x3z2-47/67x2yz2+11465xy2z2-11865y3z2+7776x2z3+124/45xyz3-98/115y2z3+117/85xz4-59/120yz4-8748z5+61/102x3yu+12668x2y2u-6653xy3u-41/54y4u+13408x3zu-2185x2yzu-1240xy2zu+1161y3zu+44/27x2z2u-11164xyz2u-13388y2z2u-107/13xz3u+90/71yz3u+4204z4u+97/125x2yu2+58/11xy2u2-46/73y3u2+55/48x2zu2+121/31xyzu2+126/61y2zu2-55/69xz2u2+5988yz2u2+3755z3u2+113/118xyu3-115/4y2u3+3390xzu3-5762yzu3+30/61z2u3+8554yu4-14317zu4+99/116x3yv-113/119x2y2v+50/23xy3v-37/79y4v-8668x3zv+14049x2yzv+111/35xy2zv+61/28y3zv-10171x2z2v+68/21xyz2v+2023y2z2v-9/109xz3v+8520yz3v-2683z4v-13547x3uv+28/65x2yuv-5988xy2uv+61/111y3uv+12314x2zuv+29/44xyzuv+6141y2zuv+11280xz2uv+79/22yz2uv-38/111z3uv+19/51x2u2v+5093xyu2v-10291y2u2v-5009xzu2v-111/49yzu2v+3813z2u2v-61/37xu3v+15914yu3v-3218zu3v-12915u4v-118/101x3v2-7/57x2yv2+13128xy2v2+11606y3v2+42/101x2zv2-54/17xyzv2-43/49y2zv2-119/110xz2v2+9742yz2v2-43/4z3v2-55/8x2uv2-29/88xyuv2+12042y2uv2+101/37xzuv2-57/62yzuv2+106/97z2uv2+38/83xu2v2+8152yu2v2-5492zu2v2-47/79u3v2+15112x2v3+69/44xyv3-6/71y2v3+113/54xzv3-13210yzv3-707z2v3-119/8xuv3+3845yuv3-19/20zuv3+4852u2v3+15761xv4-12372yv4+74/69zv4-2100uv4-12833v5,-x3yz+48/11x2y2z+8356xy3z-35/121y4z-31/66x3z2+54/83x2yz2+61/18xy2z2-11526y3z2-7372x2z3+91/60xyz3+95/97y2z3+45/71xz4-71/115yz4-25/54z5+15/52x3yu+6039x2y2u+74/99xy3u-17/40y4u+29/50x3zu-7775x2yzu+6368xy2zu+14170y3zu+52/41x2z2u+7003xyz2u-5787y2z2u-101/37xz3u-23/28yz3u-20/63z4u+41/77x3u2+8650x2yu2-15922xy2u2-16/83y3u2+7278x2zu2+31/30xyzu2-2/107y2zu2+35/122xz2u2+85/58yz2u2-757z3u2+2/101x2u3+86/17xyu3+95/59y2u3+123/22xzu3-6869yzu3-9311z2u3-105/97xu4+5699yu4+15925zu4+13528u5-154x3yv+4187x2y2v+56/107xy3v-15932y4v-5137x3zv-37/56x2yzv+9401xy2zv+92/123y3zv-79/97x2z2v+9201xyz2v+19/53y2z2v+107/20xz3v+17/77yz3v-15306z4v+3215x3uv-79/117x2yuv-9/76xy2uv-6352y3uv+93/13x2zuv-65/89xyzuv-115/4y2zuv-34/57xz2uv+39/107yz2uv+31/9z3uv+107/48x2u2v+2632xyu2v+29/96y2u2v-125/89xzu2v+29/113yzu2v+3940z2u2v-116/111xu3v+6145yu3v-105/62zu3v+101/17u4v-9281x3v2-49/107x2yv2-12154xy2v2+4/19y3v2-114/71x2zv2-15/118xyzv2+4372y2zv2+45/121xz2v2+46/111yz2v2+6614z3v2+17x2uv2+10806xyuv2-10617y2uv2-25/111xzuv2-116/27yzuv2-7/58z2uv2-686xu2v2+3/13yu2v2-17/49zu2v2-40/107u3v2+47/90x2v3-83/43xyv3-6326y2v3+49/64xzv3+113/76yzv3-122/73z2v3+10232xuv3-116/109yuv3-1990zuv3+70/51u2v3-118/19xv4-27/55yv4+21/19zv4-23/57uv4-11721v5,-3399x4y+1849x3y2-3/29x2y3+28/87xy4+10/29y5-9788x4z-49/73x3yz+13829x2y2z+118/73xy3z+13129y4z-618x3z2+92/13x2yz2+101/117xy2z2-162y3z2+24/5x2z3-29/74xyz3+2687y2z3-74/39xz4+2/57yz4+68/73x4u-13787x3yu-11659x2y2u+14729xy3u+92/53y4u+15/71x3zu-62/15x2yzu+21/85xy2zu+4938y3zu-120/37x2z2u-77/102xyz2u-4785y2z2u-83/70xz3u-12128yz3u-13592z4u-123/20x3u2+2607x2yu2+40/19xy2u2+6361y3u2-3091x2zu2+89/113xyzu2+149y2zu2-2890xz2u2-8374yz2u2+11886z3u2-49/43x2u3-9854xyu3-6943y2u3+10743xzu3-122/45yzu3-13902z2u3-103/19xu4-48/59yu4+27/86zu4+46/35u5-117/17x4v-15/7x3yv+8409x2y2v-83/28xy3v+86/35y4v+37/45x3zv+4/3x2yzv+35/38xy2zv+4015y3zv-49/111x2z2v-1260xyz2v-25/33y2z2v+116/19xz3v+93/8yz3v+5755z4v-25/89x3uv-11669x2yuv-64/107xy2uv+2993y3uv+7767x2zuv-17/95xyzuv-103/80y2zuv-14576xz2uv+80/47yz2uv+25/107z3uv+103/2x2u2v+125/117xyu2v-2/89y2u2v-5298xzu2v-50/27yzu2v-71/53z2u2v+2652xu3v+15761yu3v+2124zu3v+11/82u4v+100/63x3v2+4180x2yv2+11/39xy2v2-1221y3v2+108/125x2zv2+97/126xyzv2-7698y2zv2+13984xz2v2+1342yz2v2-84/121z3v2-26/73x2uv2-14/15xyuv2-22/37y2uv2-71/82xzuv2+12430yzuv2+103/52z2uv2-13095xu2v2+10114yu2v2-8/73zu2v2-33/97u3v2+83/105x2v3+22/45xyv3-7961y2v3-9654xzv3-54/55yzv3-3/71z2v3-10148xuv3-117/98yuv3+101/102zuv3-606u2v3+97/43xv4-68/21yv4+63/16zv4+42/17uv4+5834v5,-3399x3y2-32/113x2y3+14/99xy4+15001y5-121/115x3yz+4604x2y2z+7/2xy3z+9532y4z-3267x3z2+97/118x2yz2-14238xy2z2-80/21y3z2-12332x2z3-19/69xyz3+116/15y2z3-103/32xz4+15340yz4+10509z5+112/109x3yu-97x2y2u-40/11xy3u+90/29y4u-95/106x3zu-114/67x2yzu+113/48xy2zu+12080y3zu-44x2z2u+18/17xyz2u-4814y2z2u-103/100xz3u-96/61yz3u-205z4u-87/82x3u2-97/108x2yu2+3230xy2u2+104/83y3u2+41/86x2zu2+116/49xyzu2-59/110y2zu2+14/59xz2u2-6962yz2u2-2185z3u2+59/91x2u3+2497xyu3+3/37y2u3-13010xzu3+6/83yzu3-11448z2u3+13/72xu4-69/62yu4-2869zu4+23/73u5-20/43x3yv+5074x2y2v+28/125xy3v-2706y4v+13010x3zv-17/109x2yzv+21/4xy2zv+59/93y3zv-2406x2z2v+117/11xyz2v-14978y2z2v+70/89xz3v-33/7yz3v-13676z4v-13690x3uv+9825x2yuv-117/107xy2uv+12760y3uv-93/98x2zuv-113/64xyzuv+113/103y2zuv-9748xz2uv+11016yz2uv-10729z3uv+90/13x2u2v-13/47xyu2v-11/39y2u2v+20/69xzu2v+5531yzu2v+125/49z2u2v-11025xu3v-9621yu3v+113/109zu3v+4710u4v-107/7x3v2+110/119x2yv2-10025xy2v2-6644y3v2-5041x2zv2+5/96xyzv2+11472y2zv2-5128xz2v2+2927yz2v2+121/18z3v2-125/89x2uv2+12936xyuv2-71/47y2uv2+34/47xzuv2-75/103yzuv2-2654z2uv2-2350xu2v2-7707yu2v2+47/72zu2v2-952u3v2-21/67x2v3+58/37xyv3-8757y2v3+3615xzv3+44/123yzv3-13027z2v3-9/10xuv3+75/43yuv3+115/18zuv3+8071u2v3-26/3xv4-67/65yv4+14186zv4-41/122uv4+33/28v5,-3399x3yz-32/113x2y2z+14/99xy3z+15001y4z-9788x3z2+37/96x2yz2+7743xy2z2+31/55y3z2-618x2z3-8171xyz3+82/109y2z3+24/5xz4+88/85yz4-74/39z5-13165x3yu+3407x2y2u-12509xy3u-23/45y4u-11774x3zu-10/67x2yzu+69/79xy2zu-10/123y3zu-7636x2z2u+83/32xyz2u+51/112y2z2u+19/8xz3u+9309yz3u-44/49z4u+4089x3u2-374x2yu2-919xy2u2+98/107y3u2+2776x2zu2+85/26xyzu2+31/13y2zu2-103/82xz2u2+35/76yz2u2+59/45z3u2+2950x2u3+27/44xyu3+88/71y2u3+7/114xzu3-72/77yzu3+12917z2u3-34/67xu4-85/82yu4-55/84zu4+4690u5+11/42x3yv-19/125x2y2v-8288xy3v+9199y4v-12929x3zv+13357x2yzv-4903xy2zv-584y3zv-10/33x2z2v+59/113xyz2v+103/92y2z2v+101/69xz3v+8708yz3v-8/7z4v+13560x3uv-43/49x2yuv-121/98xy2uv+75/79y3uv-39x2zuv-88/69xyzuv-89/78y2zuv+110/67xz2uv+61/4yz2uv-98/45z3uv+82/7x2u2v-85/41xyu2v+6548y2u2v+9367xzu2v-59/81yzu2v-14408z2u2v+2363xu3v-80/11yu3v-50/17zu3v-14799u4v-53/21x3v2+9437x2yv2-117/80xy2v2+81/85y3v2-8/45x2zv2-6428xyzv2+15126y2zv2+68/89xz2v2+7/122yz2v2+9639z3v2+113/4x2uv2-8678xyuv2-104/45y2uv2-79/90xzuv2+39/101yzuv2-7234z2uv2-28/43xu2v2+1251yu2v2-97/56zu2v2+17/41u3v2+107/24x2v3+2747xyv3+9933y2v3-4199xzv3+53/83yzv3+6364z2v3-5456xuv3+618yuv3-123/55zuv3+2375u2v3+63/76xv4-115/106yv4-8811zv4-31/75uv4+10/109v5,13/89x4y+77/31x3y2+36/83x2y3-11411xy4+6936y5-12223x4z+7400x3yz+33/118x2y2z-12146xy3z+108/79y4z+82/99x3z2-9877x2yz2-79/70xy2z2-19/123y3z2-1491x2z3+7953xyz3-43/126y2z3+60/17xz4+98/57yz4-13317x4u-77/27x3yu-6811x2y2u-69/61xy3u+6144y4u+5404x3zu+121/120x2yzu-91/23xy2zu-71/106y3zu+1435x2z2u-120/13xyz2u-12019y2z2u-68/7xz3u-113/82yz3u+11526z4u-8706x3u2-89/53x2yu2-14804xy2u2+120/107y3u2+71/94x2zu2-1/70xyzu2+1532y2zu2+4470xz2u2+13/60yz2u2-115/102z3u2-82/21x2u3+27/121xyu3-4439y2u3-101/47xzu3-3186yzu3-106/101z2u3-10169xu4+19/58yu4-96/73zu4-7959u5-10526x4v-107/92x3yv+47/6x2y2v-23/43xy3v-69/62y4v+59/65x3zv-28/95x2yzv+5479xy2zv-39/77y3zv+11/69x2z2v-11713xyz2v+43/79y2z2v-15602xz3v+16/73yz3v-13952z4v+61/82x3uv-2219x2yuv-91/106xy2uv+5/37y3uv-148x2zuv+31/51xyzuv+18/101y2zuv+97/68xz2uv-73/32yz2uv+47/2z3uv+2/41x2u2v-13009xyu2v-7/60y2u2v+15779xzu2v+72/7yzu2v-11/73z2u2v-119/44xu3v-9067yu3v+3249zu3v+61/51u4v+12525x3v2-118/9x2yv2-3270xy2v2-4/25y3v2-5075x2zv2+77/40xyzv2-89/65y2zv2+17/58xz2v2-15609yz2v2+95/54z3v2-75/79x2uv2-4907xyuv2+12418y2uv2-57/17xzuv2-8746yzuv2+13/95z2uv2-124/67xu2v2+16/13yu2v2+28/23zu2v2-10847u3v2-645x2v3+106/75xyv3+6/115y2v3-8495xzv3+58/35yzv3-9398z2v3-101/72xuv3-71/20yuv3-124/65zuv3-8971u2v3+27/28xv4+12/29yv4-4276zv4+10858uv4+29/12v5,13/89x3y2+12068x2y3-15543xy4-77/79y5+6626x3yz+64/53x2y2z-6/23xy3z-47/125y4z+14403x3z2-43/78x2yz2-31/115xy2z2+94/59y3z2-118/117x2z3-11229xyz3+2268y2z3-116/85xz4+25/58yz4+3085z5+59/27x3yu+67/82x2y2u+11/6xy3u+103/47y4u-63/80x3zu-81/47x2yzu+7760xy2zu-115/56y3zu-10/17x2z2u+101/5xyz2u+15634y2z2u+1/107xz3u-9282yz3u+43/62z4u+62/55x3u2+100/113x2yu2-9205xy2u2-46/13y3u2+43/96x2zu2+10159xyzu2+692y2zu2+859xz2u2-19/74yz2u2+123/47z3u2-9/20x2u3-11391xyu3-2375y2u3+109/24xzu3-57/53yzu3-925z2u3-82/45xu4+97/34yu4+13/82zu4-108/29u5+63/10x3yv+38/17x2y2v-19/115xy3v+3150y4v+22/69x3zv+26/57x2yzv+110/27xy2zv+87/77y3zv+85/18x2z2v+39/47xyz2v-48/17y2z2v-7/27xz3v-13/100yz3v-11662z4v-17/8x3uv+37/11x2yuv+29/11xy2uv-109/88y3uv-2817x2zuv-61/44xyzuv+10/31y2zuv+10010xz2uv+51/86yz2uv-97/83z3uv-89/96x2u2v+4030xyu2v-58/77y2u2v-114/43xzu2v-37/10yzu2v-2011z2u2v+14483xu3v-109/101yu3v+121/102zu3v-79/92u4v+15113x3v2+10781x2yv2-14259xy2v2-113/48y3v2-7/94x2zv2-17/74xyzv2-5/117y2zv2-59/75xz2v2+13188yz2v2+103/43z3v2+4/125x2uv2-52/59xyuv2+85/92y2uv2-1/46xzuv2-9106yzuv2-83/11z2uv2-23/94xu2v2+6742yu2v2-35/107zu2v2-14596u3v2-117/43x2v3+1026xyv3+90/19y2v3+14671xzv3-101/100yzv3+6962z2v3+61/68xuv3+108/37yuv3-4157zuv3-3974u2v3+15677xv4+8661yv4+8459zv4-16/23uv4-37/119v5,13/89x3yz+12068x2y2z-15543xy3z-77/79y4z-12223x3z2-13941x2yz2+115/84xy2z2+13/98y3z2+82/99x2z3+7751xyz3+122/17y2z3-1491xz4+1327yz4+60/17z5+15363x3yu+9780x2y2u+19/117xy3u-1924y4u-14600x3zu+46/41x2yzu-5466xy2zu-73/12y3zu+10838x2z2u-8302xyz2u-89/113y2z2u+53/69xz3u-9224yz3u+47/33z4u-7399x3u2+89/77x2yu2+9312xy2u2-41/80y3u2-732x2zu2-6781xyzu2-8608y2zu2-9270xz2u2-117/58yz2u2-115/68z3u2-48/31x2u3-9067xyu3+97/107y2u3+73/57xzu3-2719yzu3-110/59z2u3-37/86xu4-15796yu4-61/4zu4-115/72u5+6161x3yv+4134x2y2v+677xy3v-8375y4v+1150x3zv+1551x2yzv+4157xy2zv+112/87y3zv+8171x2z2v+6040xyz2v+15651y2z2v-7/66xz3v-47/61yz3v+77/64z4v+14848x3uv+48/119x2yuv-9534xy2uv-117/95y3uv+5/4x2zuv+122xyzuv+90/31y2zuv-41/26xz2uv+31/30yz2uv-10428z3uv-9896x2u2v-71/21xyu2v-55/38y2u2v-29/22xzu2v-11092yzu2v+39/122z2u2v+93/73xu3v+22/49yu3v-21/106zu3v+56u4v+8565x3v2-1695x2yv2+2/17xy2v2+1/78y3v2-113/71x2zv2-41/100xyzv2+55/14y2zv2+15286xz2v2+17/53yz2v2+126/71z3v2-79/87x2uv2+109/97xyuv2-28/31y2uv2-6533xzuv2+22/5yzuv2-10449z2uv2+10830xu2v2-15516yu2v2+28/57zu2v2-81/22u3v2+4198x2v3+5667xyv3-7133y2v3-8408xzv3+11066yzv3-26/125z2v3-808xuv3+95/54yuv3-64/17zuv3-5267u2v3-15333xv4+42/89yv4+63/85zv4+119/113uv4-2011v5,5583x4y+1725x3y2-8652x2y3-91/25xy4-8495x4z-13731x3yz+9298x2y2z-41/111xy3z-15503y4z-13805x3z2+3962x2yz2-2/63xy2z2+3314y3z2+2522x2z3-10/87xyz3-408y2z3+7/16xz4+69/22yz4-7254z5-59/21x4u+115/7x3yu-1718x2y2u+7851xy3u+2632y4u-82/3x3zu+37/86x2yzu+101/113xy2zu+6747y3zu-109/113x2z2u+7399xyz2u+24/103y2z2u+89/9xz3u-14630yz3u+15066z4u-12561x3u2+113/115x2yu2+87/97xy2u2-126/67y3u2-48/7x2zu2+123/103xyzu2-11/107y2zu2-2747xz2u2+8158yz2u2-3/107z3u2+41/6x2u3+12767xyu3+3873y2u3+74/83xzu3-55/119yzu3-24/83z2u3+55xu4-7/95yu4+57/44zu4+2/101u5-6928x4v-121/57x3yv+111/104x2y2v+946xy3v-29y4v+3057x3zv-14/25x2yzv+43/31xy2zv-105/2y3zv+2336x2z2v+61/77xyz2v-7880y2z2v+5/58xz3v+10593yz3v+7094z4v+63/59x3uv-5/69x2yuv-11/81xy2uv-4157y3uv+73/65x2zuv-1676xyzuv-2376y2zuv-85/63xz2uv-95/2yz2uv-14903z3uv-119/110x2u2v-115/24xyu2v+125/9y2u2v+106/87xzu2v-13/12yzu2v-4/19z2u2v+7838xu3v-43/111yu3v+7/113zu3v-12500u4v+7743x3v2-2023x2yv2-85/83xy2v2+49/41y3v2+20/87x2zv2+3932xyzv2-77/6y2zv2+47/90xz2v2-15580yz2v2+39/4z3v2-61/8x2uv2+2518xyuv2+29/98y2uv2+11057xzuv2-18/107yzuv2+708z2uv2+14720xu2v2-3175yu2v2-113/59zu2v2-14735u3v2+7/69x2v3-4029xyv3+54/91y2v3+12372xzv3+67/2yzv3+8856z2v3-2178xuv3+995yuv3+64/95zuv3+4039u2v3-37/44xv4+23/17yv4-3035zv4-103/124uv4+69/64v5,-5583x3y2-1725x2y3+8652xy4+91/25y5+6201x3yz-73/49x2y2z-3844xy3z+10548y4z-11057x3z2-105/122x2yz2+31/53xy2z2+79/89y3z2-24/101x2z3+107/119xyz3-126y2z3+8164xz4+2/77yz4-51/8z5-14941x3yu-106x2y2u+8695xy3u+125/62y4u+4328x3zu+29/117x2yzu-6249xy2zu-2791y3zu+67/49x2z2u-38/29xyz2u+122/41y2z2u+10603xz3u-3029yz3u+5578z4u+14754x3u2-108/79x2yu2+4408xy2u2-12401y3u2-1426x2zu2-1741xyzu2-83/86y2zu2+79/95xz2u2+122/121yz2u2+81/2z3u2-1172x2u3-41/68xyu3-70/3y2u3+24/107xzu3+120/79yzu3+18/119z2u3-65/122xu4+1018yu4+22/107zu4+15189u5+5/8x3yv-12060x2y2v+3/62xy3v-227y4v+60/41x3zv-123/115x2yzv+110/123xy2zv+12864y3zv-86/121x2z2v-69/94xyz2v+14/79y2z2v+118/45xz3v+10842yz3v-37/58z4v+100/69x3uv-47/65x2yuv-7/67xy2uv-93/100y3uv-6262x2zuv-4/75xyzuv+2082y2zuv-9117xz2uv+12450yz2uv-84/67z3uv+123/26x2u2v-51/89xyu2v+19/74y2u2v-104/77xzu2v+318yzu2v+12402z2u2v+95/8xu3v-81/26yu3v-4486zu3v+3872u4v+72/91x3v2-83/63x2yv2+93/92xy2v2-15924y3v2-53/62x2zv2+6046xyzv2+1408y2zv2+60/107xz2v2-1150yz2v2-126/19z3v2-7429x2uv2+2554xyuv2+3602y2uv2+10738xzuv2-57/64yzuv2+86/69z2uv2+8172xu2v2+91/113yu2v2+92/65zu2v2+118/37u3v2+47/83x2v3+12750xyv3+10851y2v3+4216xzv3+6/101yzv3-108z2v3+2920xuv3-101/102yuv3-157zuv3+7742u2v3-7234xv4-2/111yv4+59/33zv4-93/91uv4+24/19v5,1592x4y+75/121x3y2+40/19x2y3-2651xy4+9934x4z+245x3yz+11665x2y2z+30/41xy3z+1823y4z+89/88x3z2-105/46x2yz2+79/58xy2z2-4191y3z2-76/61x2z3-21/32xyz3-9516y2z3-14896xz4-85/77yz4+51/109z5+61/30x4u-10/101x3yu+11796x2y2u+76/101xy3u+123/88y4u-5932x3zu-11857x2yzu+7128xy2zu-45/79y3zu+119/18x2z2u+9/74xyz2u+7042y2z2u-1114xz3u-11/82yz3u-1466z4u-6/85x3u2+27/106x2yu2+14246xy2u2-6216y3u2+47/6x2zu2-45/59xyzu2+89/41y2zu2+41/80xz2u2-7583yz2u2-75/113z3u2-14808x2u3-10873xyu3-90/67y2u3-11081xzu3-7369yzu3-7131z2u3-1402xu4-15386yu4-108/73zu4-5039u5+120/113x4v+10617x3yv-50/87x2y2v-2395xy3v-20/69y4v-8587x3zv+12960x2yzv-41/50xy2zv-13844y3zv-65/32x2z2v-77/122xyz2v-85/66y2z2v+13/100xz3v-20/51yz3v-13676z4v+76/97x3uv+1046x2yuv-8059xy2uv-117/59y3uv-29/105x2zuv+7287xyzuv-107/119y2zuv-35/118xz2uv+79/86yz2uv-2211z3uv+5448x2u2v+62/35xyu2v-2275y2u2v+29/121xzu2v-1674yzu2v-56/43z2u2v-3377xu3v-43/110yu3v+23/10zu3v-24/61u4v+121/53x3v2-4745x2yv2-57/64xy2v2+9554y3v2-12741x2zv2+10449xyzv2+37/108y2zv2+8621xz2v2-11/57yz2v2+1566z3v2+125/49x2uv2-121/118xyuv2+109/84y2uv2-335xzuv2+10167yzuv2-59/109z2uv2-103/119xu2v2+43/13yu2v2-73/87zu2v2+2037u3v2+13002x2v3+83/48xyv3-10713y2v3+1026xzv3-105/64yzv3-37/6z2v3+14779xuv3-6448yuv3+19/69zuv3-1/110u2v3+10010xv4+79/12yv4+12/19zv4-35/61uv4-11/57v5,-1592x3y2-75/121x2y3-40/19xy4+2651y5+39/121x3yz+122/77x2y2z-114/31xy3z+1544y4z+2/3x3z2-10271x2yz2-8373xy2z2+56/61y3z2+55/48x2z3-116xyz3-25/7y2z3-108/113xz4-34/53yz4+5548z5-122x3yu-9690x2y2u+43/87xy3u-5/19y4u+97/54x3zu-17/19x2yzu+4355xy2zu+12/5y3zu-1/100x2z2u+12754xyz2u+13600y2z2u+17/45xz3u-12091yz3u+5145z4u-63/64x3u2-84/31x2yu2-97/41xy2u2+7/13y3u2-79/62x2zu2-80/103xyzu2-69/14y2zu2+119/4xz2u2-35/87yz2u2-13840z3u2+14101x2u3+7952xyu3-1857y2u3-9861xzu3+3180yzu3+75/107z2u3-250xu4-15134yu4+4717zu4-2/41u5+22/27x3yv-8983x2y2v+10520xy3v-113/2y4v+10/73x3zv-1986x2yzv-110/13xy2zv+1550y3zv+32/111x2z2v-111/35xyz2v+101/98y2z2v+8045xz3v-2/89yz3v+2924z4v-79/11x3uv-15178x2yuv+10874xy2uv+54/11y3uv-8950x2zuv+70/53xyzuv-2403y2zuv-8249xz2uv+6935yz2uv+20/89z3uv+885x2u2v-76/71xyu2v-4/17y2u2v-31/52xzu2v-4/99yzu2v+10333z2u2v-93/104xu3v+82/101yu3v-71/37zu3v+9397u4v-15/112x3v2-6614x2yv2+119/2xy2v2+88/119y3v2+306x2zv2+2790xyzv2+10992y2zv2-115/74xz2v2-14711yz2v2+11612z3v2-1788x2uv2-75/97xyuv2+79/30y2uv2+99/59xzuv2-11439yzuv2-121/113z2uv2+108/37xu2v2+37/36yu2v2-3/65zu2v2-55/42u3v2+13/100x2v3-209xyv3-1272y2v3-117/68xzv3+63/94yzv3+32/59z2v3+1013xuv3-3463yuv3+6946zuv3-37/86u2v3+67/117xv4+85/28yv4-3024zv4-82/9uv4-32/65v5,-35/52x4y-12140x3y2+23/83x2y3+69/5xy4-80/79y5+120/43x4z-11865x3yz-3487x2y2z+53/59xy3z+53/102y4z-14083x3z2-14430x2yz2-2442xy2z2-33/104y3z2-91/38x2z3+4/87xyz3-26/57y2z3+4097xz4-9/122yz4+6364z5+9634x4u-97/95x3yu-46/99x2y2u+3847xy3u+121/106y4u+12765x3zu-5292x2yzu+1607xy2zu-67/121y3zu-12/35x2z2u+4/55xyz2u-17/27y2z2u+91/122xz3u-23/31yz3u+65/49z4u+73/46x3u2-124/27x2yu2-9933xy2u2+46/75y3u2+53/114x2zu2+3503xyzu2-14147y2zu2-11283xz2u2+11889yz2u2+99/104z3u2+3117x2u3+12624xyu3-10060y2u3+2193xzu3-80/47yzu3-77/13z2u3+11/31xu4-47/90yu4+49/48zu4-2/105u5-92/61x4v+7443x3yv+35/76x2y2v+114/67xy3v-73/126y4v+97/107x3zv+9464x2yzv+10869xy2zv+15718y3zv-37/33x2z2v+124/13xyz2v-11/26y2z2v-61/40xz3v+91/100yz3v-18/103z4v+60/29x3uv+21/125x2yuv-11117xy2uv+11748y3uv-16/117x2zuv+18/103xyzuv-1711y2zuv+1872xz2uv-109/123yz2uv-18/113z3uv-26/103x2u2v+14140xyu2v+11065y2u2v+8686xzu2v-5/111yzu2v+30/101z2u2v-10501xu3v-36/113yu3v-73/74zu3v+12753u4v-43/52x3v2-76/15x2yv2-5793xy2v2+18/13y3v2+1/79x2zv2+84/23xyzv2-172y2zv2+86/77xz2v2+15/37yz2v2+11835z3v2-6482x2uv2+94/113xyuv2+10727y2uv2-102/41xzuv2+15914yzuv2-12973z2uv2-9038xu2v2-13107yu2v2+1533zu2v2+12549u3v2-13528x2v3+903xyv3+23/114y2v3-123/64xzv3-81/5yzv3+111/103z2v3+4734xuv3-33/20yuv3-7954zuv3-2478u2v3+15518xv4-6723yv4-14/31zv4-3482uv4+10919v5,-3/94x4y-12936x3y2+2/11x2y3+32/23xy4-15921y5+61/93x4z+82/111x3yz-93/2x2y2z-6659xy3z-97/90y4z+402x3z2-14586x2yz2-121/39xy2z2+68/7y3z2+1212x2z3-2980xyz3+49/52y2z3-72/89xz4+92/47yz4+8478z5+2733x4u-103/89x3yu+1166x2y2u-7/53xy3u-106/23y4u+677x3zu+907x2yzu+7891xy2zu-9014y3zu+76/47x2z2u+49/116xyz2u-49/78y2z2u+12261xz3u+118/105yz3u-126/13z4u-8812x3u2-97/120x2yu2-9534xy2u2+92/5y3u2-54/71x2zu2+94/103xyzu2+2256y2zu2+4182xz2u2-5798yz2u2-31/115z3u2-73/98x2u3+15822xyu3+1004y2u3-578xzu3+9494yzu3-6779z2u3+14506xu4+10/121yu4+58/27zu4-2817u5-19/119x4v+7128x3yv+75/64x2y2v-65/109xy3v+5129y4v-53/55x3zv+54/125x2yzv-3009xy2zv+6144y3zv+15601x2z2v+123/55xyz2v-58/77y2z2v-56/61xz3v+121/10yz3v-103/86z4v-93/25x3uv+94/123x2yuv-25/107xy2uv+14807y3uv+65/7x2zuv+87/44xyzuv+6605y2zuv+23/99xz2uv-413yz2uv-17/15z3uv-79/46x2u2v+15240xyu2v-42/67y2u2v+8932xzu2v-5888yzu2v-4204z2u2v+7002xu3v-36/97yu3v-1634zu3v+61/102u4v-14/33x3v2-6520x2yv2+9004xy2v2-67/36y3v2-7/8x2zv2-24/11xyzv2-9373y2zv2+1556xz2v2-79/74yz2v2-6691z3v2+108x2uv2-76/61xyuv2+220y2uv2-1191xzuv2-4/9yzuv2+4546z2uv2+12205xu2v2+9/22yu2v2+64/93zu2v2-44/125u3v2+292x2v3+41/74xyv3+16/79y2v3-15892xzv3+5733yzv3+6796z2v3-42/55xuv3+71/79yuv3-19/104zuv3-38/15u2v3+6436xv4+28/15yv4+87/55zv4+2270uv4-30/41v5,-117/4x3y+97/122x2y2-3618xy3+6566y4+97/113x3z-12634x2yz+9865xy2z-1764y3z+114/31x2z2+5006xyz2+7/44y2z2-15040xz3+8/125yz3+11134z4-12980x3u-79/41x2yu-79/98xy2u+89/65y3u-1217x2zu+89/87xyzu+83/66y2zu+115/11xz2u+123/107yz2u+10920z3u-86/73x2u2-11/94xyu2-14054y2u2+6752xzu2-123/124yzu2+12129z2u2-13310xu3-52/63yu3+12847zu3-1545u4-11064x3v+11499x2yv-37/64xy2v+50/103y3v+123/94x2zv-126xyzv-111/44y2zv+95/14xz2v+113/83yz2v-77/103z3v+41/64x2uv+91/90xyuv-4932y2uv+103/31xzuv+62/63yzuv+1161z2uv-99/106xu2v-3181yu2v-11741zu2v-33/8u3v-3/118x2v2-9369xyv2+527y2v2-113/39xzv2-88/49yzv2-113/101z2v2+95/68xuv2-5930yuv2-20/43zuv2+7/41u2v2+109/93xv3-107/61yv3-8352zv3-5255uv3+12021v4,-2159x4-94/3x3y-4602x2y2+1609xy3+10721y4+28/9x3z-99/35x2yz+1/110xy2z+113/114y3z-118/75x2z2-103/93xyz2-68/67y2z2+13687xz3-1531yz3+61/107z4+6076x3u+9004x2yu+2211xy2u+110/53y3u+47/102x2zu+8495xyzu-9238y2zu+57/121xz2u-8543yz2u+8/19z3u-13527x2u2-13293xyu2+1138y2u2+26/115xzu2+78/53yzu2-12556z2u2+7299xu3+70/19yu3-14687zu3+13559u4+113/9x3v-85/126x2yv-83/3xy2v-3/46y3v+1814x2zv+28/79xyzv+103/51y2zv+78/31xz2v-14387yz2v+1/88z3v+116/75x2uv-101/59xyuv-70/3y2uv+109/71xzuv+13/88yzuv-147z2uv-113/76xu2v-9661yu2v+13855zu2v-6162u3v-1857x2v2-8208xyv2-4634y2v2-6178xzv2-7352yzv2-8247z2v2-113/15xuv2+99/40yuv2+21/97zuv2+11/37u2v2-6605xv3+8964yv3+35/121zv3+8543uv3-6008v4;TestGRRes(Name, 2, I); kill R, Name, @p; "";
-}
-
+
+  if( defined(assumeLevel0) ){ assumeLevel = assumeLevel0; } else { kill assumeLevel; } // restore the state of aL
+}
+
+/////////////////////////////////////////////////////////
+
+// ????
+proc grzero()
+"presentation of S(0)^1
+TODO: can we return this as an undefined value?????
+"
+{
+ module Z = 0;
+ return ( grobj(Z,intvec(0)) );
+}
+
+proc grpower(def A, int p)
+"
+compute A \oplus ... \opuls A (p-times)
+"
+{
+  if(p==0){ return ( grzero() ); } // just ERROR ???
+
+  ASSUME(0, p > 0);
+
+  if(p==1){ return(A); }
+
+  def N = grsum(A,A);
+
+  if(p==2){ return(N); }
+
+  // TODO: replace recursion with a loop!
+  // see http://en.wikipedia.org/wiki/Exponentiation_by_squaring
+  if((p%2)==0)
+    { return ( grpower(N, p div 2) ); }
+  else
+    { return ( grsum( A, grpower(N, (p-1) div 2) )); }
+}  
+  
+
+proc grsum(def A,def B)
+"
+direct sum of graded modules
+"
+{
+  intvec a = attrib(A, "isHomog");
+  intvec b = attrib(B, "isHomog");
+  intvec c = a,b;                       
+  int r = nrows(A);
+  
+  ASSUME( 0, r == size(a) );
+  
+  module T; T[r] = 0; T = T, module(transpose(B));
+  module AB = module(A), transpose(T);
+  
+  return(grobj(AB, c));
+}
+example
+{ "EXAMPLE:"; echo = 2; 
+
+  if( defined(assumeLevel) ){ int assumeLevel0 = assumeLevel; } else { int assumeLevel; export(assumeLevel); }  // store the state of aL
+  assumeLevel = 5;
+  
+  ring r=32003,(x,y,z),dp;
+
+  grview(grpower( grshift(grzero(), 10), 5 ) );
+  
+  module A = grobj( module([x+y, x, 0, 0], [0, x+y, y, 0]), intvec(0,0,0,1) );  
+  grview(A);
+  
+  module B = grobj( module([0,x,y]), intvec(15,1,1) );
+  grview(B);
+
+  module C = grsum(A,B);
+
+  print(C);
+  homog(C);
+  grview(C);
+
+  module D = grsum(
+     grsum(grpower(A,2), grtwist(1,1)), 
+     grsum(grtwist(1,2), grpower(B,2))
+     );
+
+  print(D);
+  homog(D);
+  grview(D);
+
+  module D10 = grshift(D, 10);
+
+  print(D10);
+  homog(D10);
+  grview(D10);
+
+  module DD = grorder(D10);
+
+  print(DD);
+  homog(DD);
+  grview(DD);
+
+  module TTT = grtranspose(DD);
+
+  print(TTT);
+  homog(TTT);
+  grview(TTT);
+
+  module F = grobj( module([x,y,0]), intvec(1,1,5) );
+  grview(B);
+  
+  module T = grsum( F, grsum( grtwist(1, 10), B ) );
+  grview(T);
+
+  if( defined(assumeLevel0) ){ assumeLevel = assumeLevel0; } else { kill assumeLevel; } // restore the state of aL
+}
+
+proc grshift( def M, int d)
+"
+shift graded module M by delta so that 1 is in M_d
+"
+{
+  intvec a = attrib(M, "isHomog");
+  return (grobj(M, intvec( a - intvec(d:size(a))) ));
+}
+
+proc grisequal (def A, def B)
+"TODO"
+{
+  return (1==1); // TODO!
+}
+
+proc grtwist(int a, int d)
+"
+matrix presentation for twisted polynomial ring S(d)^a
+"
+{
+  module Z; Z[a] = 0; 
+  Z = grobj(Z, -intvec(d:a));
+
+  ASSUME(2, grisequal(Z, grpower( grshift(grzero(), -d), a ) )); // optional check
+  return(Z); 
+}
+
+proc grobj(module M, intvec w)
+""
+{
+  attrib(M, "isHomog", w);
+  attrib(M, "rank", size(w));
+  return (M);
+}

Singular/LIB/primdec.lib

@@ -26 +26 @@
 
 PROCEDURES:
- Ann(M);           annihilator of R^n/M, R=basering, M in R^n
- primdecGTZ(I);    complete primary decomposition via Gianni,Trager,Zacharias
- primdecSY(I...);  complete primary decomposition via Shimoyama-Yokoyama
- minAssGTZ(I);     the minimal associated primes via Gianni,Trager,Zacharias (with modifications by Laplagne)
- minAssChar(I...); the minimal associated primes using characteristic sets
- testPrimary(L,k); tests the result of the primary decomposition
- radical(I);       computes the radical of I via Krick/Logar (with modifications by Laplagne) and Kemper
- radicalEHV(I);    computes the radical of I via Eisenbud,Huneke,Vasconcelos
- equiRadical(I);   the radical of the equidimensional part of the ideal I
- prepareAss(I);    list of radicals of the equidimensional components of I
- equidim(I);       weak equidimensional decomposition of I
- equidimMax(I);    equidimensional locus of I
- equidimMaxEHV(I); equidimensional locus of I via Eisenbud,Huneke,Vasconcelos
- zerodec(I);       zerodimensional decomposition via Monico
- absPrimdecGTZ(I); the absolute prime components of I
- sep(f,k);         the separabel part of f as polynomial in Fp(t1,...,tm)
+ Ann(M);            annihilator of R^n/M, R=basering, M in R^n
+ primdecGTZ(I);     (deprecated) complete primary decomposition via Gianni,Trager,Zacharias
+ primdecGTZE(I);    complete primary decomposition via Gianni,Trager,Zacharias. Returns empty list for the unit ideal
+ primdecSY(I...);   (deprecated) complete primary decomposition via Shimoyama-Yokoyama
+ primdecSYE(I,..);  complete primary decomposition via Shimoyama-Yokoyama. Returns empty list for the unit ideal
+ minAssGTZ(I);      (deprecated) the minimal associated primes via Gianni,Trager,Zacharias (with modifications by Laplagne)
+ minAssGTZE(I);     the minimal associated primes via Gianni,Trager,Zacharias. Returns empty list for unit ideal
+ minAssChar(I...);  (deprecated) the minimal associated primes using characteristic sets
+ minAssCharE(I..);  the minimal associated primes using characteristic sets. Returns empty list for unit ideal
+ testPrimary(L,k);  (deprecated) tests the result of the primary decomposition
+ testPrimaryE(L,k); tests the result of the primary decomposition. Handles also empty list L.
+ radical(I);        computes the radical of I via Krick/Logar (with modifications by Laplagne) and Kemper
+ radicalEHV(I);     computes the radical of I via Eisenbud,Huneke,Vasconcelos
+ equiRadical(I);    the radical of the equidimensional part of the ideal I
+ prepareAss(I);     list of radicals of the equidimensional components of I
+ equidim(I);        weak equidimensional decomposition of I
+ equidimE(I);       equidimE returns empty list for unit ideal
+ equidimMax(I);     equidimensional locus of I
+ equidimMaxEHV(I);  equidimensional locus of I via Eisenbud,Huneke,Vasconcelos
+ zerodec(I);        zerodimensional decomposition via Monico
+ absPrimdecGTZ(I);  (deprecated) the absolute prime components of I
+ absPrimdecGTZE(I); the absolute prime components of I. Assumes I is not unit ideal.
+ sep(f,k);          the separabel part of f as polynomial in Fp(t1,...,tm)
 ";
+
+
 
 LIB "general.lib";
@@ -58 +67 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
+
 
 static proc sat1 (ideal id, poly p)
@@ -463 +473 @@
       if(e mod char(basering)==0)
       {
-        if ( voice >=15 )
+        if ( voice >=16 )
         {
           "// WARNING: The characteristic is perhaps too small to use";
@@ -1014 +1024 @@
   }
 
-  if((voice>=6)&&(char(basering)<=181))
+  if((voice>=7)&&(char(basering)<=181))
   {
     primary=splitCharp(primary);
   }
 
-  if((@wr==2)&&(npars(basering)>0)&&(voice>=6)&&(char(basering)>0))
+  if((@wr==2)&&(npars(basering)>0)&&(voice>=7)&&(char(basering)>0))
   {
   //the prime decomposition of Yokoyama in characteristic p
@@ -1029 +1039 @@
       if(size(primary[2*@k])==0)
       {
-        ek=insepDecomp(primary[2*@k-1]);
+        ek=insepDecomp_i( int(1), primary[2*@k-1] );
         primary=delete(primary,2*@k);
         primary=delete(primary,2*@k-1);
@@ -1043 +1053 @@
   }
 
-  if(voice>=8){primary=extF(primary);};
+  if(voice>=9){primary=extF(primary);};
 
 //test whether all ideals in the decomposition are primary and
@@ -1049 +1059 @@
 //if not after a random coordinate transformation of the last
 //variable the corresponding ideal is decomposed again.
-  if((npars(basering)>0)&&(voice>=8))
+  if((npars(basering)>0)&&(voice>=9))
   {
     poly randp;
@@ -1087 +1097 @@
       jmap2=maxideal(1);
       @qht=primary[2*@k-1];
-      if((npars(basering)>0)&&(voice>=10))
+      if((npars(basering)>0)&&(voice>=11))
       {
         jmap[size(jmap)]=randp;
@@ -1542 +1552 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc insepDecomp(ideal i)
+
+proc insepDecomp_i(int patchPrimaryDecomposition, ideal i)
 {
 //decomposes i into special ideals
 //computes the prime decomposition of the special ideals
 //and transforms it back to a decomposition of i
+// if patchPrimaryDecomposition=1,  drop unit ideal in the decomposition, 
+// since the unit ideal it is not prime!
 
   ASSUME(0, hasFieldCoefficient(basering) );
@@ -1569 +1582 @@
     }
     phi=R,m;
-    qr=decomp(wo[1],2);
+    qr = decomp_i(patchPrimaryDecomposition,wo[1],2);
 
     option(redSB);
@@ -1579 +1592 @@
       re[size(re)+1]=zeroRad(K);
     }
-    option(noredSB);
+    option(set,op);
   }
   option(set,op);
@@ -1714 +1727 @@
 }
 
-static proc teilt(intvec a, intvec b)
+static proc teilt(intvec aba, intvec bab)
 {
   int i;
-  for(i=1;i<=size(a);i++)
-  {
-    if(a[i]>b[i]){return(0);}
+  for(i=1;i<=size(aba);i++)
+  {
+    if(aba[i]>bab[i]){return(0);}
   }
   return(1);
@@ -1935 +1948 @@
 
 
-proc minAssPrimesold(ideal i, list #)
-"USAGE:   minAssPrimes(i); i ideal
-         minAssPrimes(i,1); i ideal  (to use also the factorizing Groebner)
-RETURN:  list = the minimal associated prime ideals of i
-EXAMPLE: example minAssPrimes; shows an example
+ proc minAssPrimesoldE(ideal I, list #)
+"USAGE:   minAssPrimesoldE(I); I ideal
+         minAssPrimesold(I,1); I ideal  (to use also the factorizing Groebner)
+RETURN:  list = the minimal associated prime ideals of I
+EXAMPLE: example minAssPrimesoldE; shows an example
 "
 {
+    return(minAssPrimesold_i(int(1),I,#));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring  r = 32003,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z4+2;
+   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   list pr= minAssPrimesoldE(i);  pr;
+
+   minAssPrimesoldE(i,1);
+}
+
+proc minAssPrimesold(ideal I, list #)
+"USAGE:   minAssPrimesold(I); I ideal
+         minAssPrimesold(i,1); I ideal  (to use also the factorizing Groebner)
+RETURN:  list = the minimal associated prime ideals of I. In case I is unit ideal, returns list(ideal(1));
+NOTE:    deprecated. Use 'minAssPrimesoldE()'
+EXAMPLE: example minAssPrimesold; shows an example
+"
+{
+    return(minAssPrimesold_i(int(0),I,#));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring  r = 32003,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z4+2;
+   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   list pr= minAssPrimesold(i);  pr;
+
+   minAssPrimesold(i,1);
+}
+
+static proc minAssPrimesold_i(int patchPrimaryDecomposition, ideal i, list #)
+{
+//
+// parameter patchPrimaryDecomposition : if = 1, patch the decomposition( drop unit ideal in the decomposition), 
+//                                 : if = 0, taken no special action in case the unit ideal is in the decomposition
+// for other parameters see minAssPrimesold, minAssPrimesoldE
+
    ASSUME(1, hasFieldCoefficient(basering) );
    ASSUME(0, not isQuotientRing(basering) ) ;
    ASSUME(0, hasGlobalOrdering(basering) ) ;
    def @P=basering;
-   if(size(i)==0){return(list(ideal(0)));}
+   if(size(i)==0) { return(list(ideal(0))); }
    list qr=simplifyIdeal(i);
    map phi=@P,qr[2];
@@ -1959 +2013 @@
       int @wr;
       list tluser,@res;
-      list primary=decomp(i,2);
+      list primary=decomp_i(patchPrimaryDecomposition,i,2);
 
       @res[1]=primary;
 
       tluser=union(@res);
-      setring @P;
-      list @res=imap(gnir,tluser);
-      return(phi(@res));
+
+      if (size(tluser)>0)
+      {
+          setring @P;
+          list @res=imap(gnir,tluser);
+          return(phi(@res));
+      }
+      else 
+      {
+          setring @P;
+          return(tluser);
+      }
    }
    list @res,empty;
@@ -2028 +2091 @@
         if(pos[j]!=1)
         {
-            @res[j]=decomp(@pr[j],2);
+            @res[j]=decomp_i(patchPrimaryDecomposition,@pr[j],2);
         }
         else
@@ -2043 +2106 @@
 //@pr[j];
 //pause();
-        @res[j]=decomp(@pr[j],2);
-//       @res[j]=decomp(@pr[j],2,@pr[j],ser);
+        @res[j]=decomp_i(patchPrimaryDecomposition,@pr[j],2);
+//       @res[j]=decomp_i(patchPrimaryDecomposition,@pr[j],2,@pr[j],ser);
 //       for(k=1;k<=size(@res[j]);k++)
 //       {
@@ -2057 +2120 @@
    return(phi(@res));
 }
-example
-{ "EXAMPLE:"; echo = 2;
-   ring  r = 32003,(x,y,z),lp;
-   poly  p = z2+1;
-   poly  q = z4+2;
-   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
-   list pr= minAssPrimes(i);  pr;
-
-   minAssPrimes(i,1);
-}
+
 
 static proc primT(ideal i)
@@ -2090 +2144 @@
 }
 
-static proc minAssPrimes(ideal i, list #)
-"USAGE:   minAssPrimes(i); i ideal
+
+static proc minAssPrimesE(ideal I, list #)
+"USAGE:   minAssPrimesE(I); I ideal
       Optional parameters in list #: (can be entered in any order)
       0, "facstd"   ->   uses facstd to first decompose the ideal
@@ -2097 +2152 @@
       "SL" ->     the new algorithm is used (default)
       "GTZ" ->     the old algorithm is used
-RETURN:  list = the minimal associated prime ideals of i
+RETURN:  list = the minimal associated prime ideals of I
+EXAMPLE: example minAssPrimesE; shows an example
+"
+{
+    return(minAssPrimes_i(int(1),I,#));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring  r = 32003,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z4+2;
+   ideal I = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   list pr= minAssPrimesE(I);  pr;
+
+   minAssPrimesE(I,1);
+}
+
+static proc minAssPrimes(ideal I, list #)
+"USAGE:   minAssPrimes(I); I ideal
+      Optional parameters in list #: (can be entered in any order)
+      0, "facstd"   ->   uses facstd to first decompose the ideal
+      1, "noFacstd" ->  does not use facstd (default)
+      "SL" ->     the new algorithm is used (default)
+      "GTZ" ->     the old algorithm is used
+RETURN:  list = the minimal associated prime ideals of I. If I is the unit ideal returns list(ideal(1)) ;
+NOTE:    deprecated. Use 'minAssPrimesE()'
 EXAMPLE: example minAssPrimes; shows an example
 "
 {
+    return(minAssPrimes_i(int(0),I,#));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring  r = 32003,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z4+2;
+   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   list pr= minAssPrimes(i);  pr;
+
+   minAssPrimes(i,1);
+}
+
+
+static proc minAssPrimes_i(int patchPrimaryDecomposition, ideal i, list #)
+{
+// parameter  patchPrimaryDecomposition:  1 to patch( remove unit ideal from the decomposition) , 
+//                                        0 for no special action on unit ideal.
+// for other parameters see 'minAssPrimes', 'minAssPrimesE'
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
   ASSUME(1, hasGlobalOrdering(basering) ) ;
-
-  if(size(i) == 0){return(list(ideal(0)));}
+  if (size(i) == 0)  {  return(list(ideal(0)));  }
+
+  intvec origOp = option(get);
+
   string algorithm;    // Algorithm to be used
   string facstdOption;    // To uses proc facstd
@@ -2160 +2261 @@
   list result;
 
-  if(npars(P) == 0){option(redSB);}
-
-  if(attrib(i,"isSB")!=1)
+  if(npars(P) == 0)  { option(redSB); }
+
+  if (attrib(i,"isSB")!=1)
   {
     i=groebner(q[1]);
@@ -2170 +2271 @@
     for(j=1;j<=nvars(basering);j++)
     {
-      if(q[2][j]!=var(j)){k=1;break;}
+      if (q[2][j]!=var(j)) {k=1;break;}
     }
     if(k)
@@ -2176 +2277 @@
       i=groebner(q[1]);
     }
+  }
+  if(size(i)==1)
+  {
+      if ( deg(lead(i[1]))==0 ) // we have the unit ideal.
+      { 
+          setring P0; 
+          option( set,origOp );
+          if (patchPrimaryDecomposition==1)
+          {
+
+             return( list() ); 
+          }
+          else
+          {
+               return( list(ideal(1)) ); 
+          }
+      }
   }
 
@@ -2182 +2300 @@
     option( set,op );
     setring P0;
+    option( set,origOp );
     return( ideal(1) );
   }
@@ -2212 +2331 @@
         if (algorithm == "GTZ")
         {
-          qr = decomp(pr[k], 2);
+          qr = decomp_i(patchPrimaryDecomposition,pr[k], 2);
         }
         else
@@ -2230 +2349 @@
     setring(P0);
     list re=imap(P,re);
+    option( set,origOp );
     return(re);
   }
@@ -2238 +2358 @@
     if (algorithm == "GTZ")
     {
-      re[1] = decomp(i, 2);
+      re[1] = decomp_i(patchPrimaryDecomposition,i, 2);
     }
     else
@@ -2248 +2368 @@
     re=phi(re);
     setring(P0);
+    option( set,origOp );
     list re=imap(P,re);
     return(re);
@@ -2282 +2403 @@
     if (algorithm == "GTZ")
     {
-      re[j] = decomp(q[j], 2);
+      re[j] = decomp_i(patchPrimaryDecomposition,q[j], 2);
     }
     else
@@ -2296 +2417 @@
   setring(P0);
   list re=imap(P,re);
+  option( set,origOp );
   return(re);
 }
-example
-{ "EXAMPLE:"; echo = 2;
-   ring  r = 32003,(x,y,z),lp;
-   poly  p = z2+1;
-   poly  q = z4+2;
-   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
-   list pr= minAssPrimes(i);  pr;
-
-   minAssPrimes(i,1);
-}
+
 
 static proc union(list li)
@@ -2315 +2428 @@
   def P=basering;
 
+  int liSize=size(li);
+  int li1Size=0;
+  if (size(li)>0) 
+  {
+     li1Size=size(li[1]);
+  }
   def ir=changeordTo(basering,"lp");
   setring ir;
-  list l=fetch(P,li);
+  list l;
+  if ( liSize > 0) 
+  {
+     if (li1Size > 0) 
+     {
+         l = fetch(P,li);
+     }
+     else
+     {
+         ASSUME(1, size(li)==1);
+         l[1] = list();
+     }
+  }
   list @erg;
 
@@ -2375 +2506 @@
      }
   }
-  if(deg(@erg[size(@erg)][1])!=0)
-  {
-     @wos[size(@wos)+1]=@erg[size(@erg)];
-  }
+  if (size(@erg)>0)
+  {
+     if(deg(@erg[size(@erg)][1])!=0)
+     {
+        @wos[size(@wos)+1]=@erg[size(@erg)];
+     }
+  }
+  int @wosSize = size(@wos);
   setring P;
-  list @ser=fetch(ir,@wos);
+  list @ser;
+  if (@wosSize>0)
+  {
+      @ser=fetch(ir,@wos);
+  }
   return(@ser);
 }
-///////////////////////////////////////////////////////////////////////////////
+
+
+
+
 proc equidim(ideal i,list #)
-"USAGE:  equidim(i) or equidim(i,1) ; i ideal
+"USAGE:  equidim(I) or equidim(I,1) ; I ideal
 RETURN: list of equidimensional ideals a[1],...,a[s] with:
-        - a[s] the equidimensional locus of i, i.e. the intersection
-          of the primary ideals of dimension of i
+        - a[s] the equidimensional locus of I, i.e. the intersection
+          of the primary ideals of dimension of I, except I is unit ideal. 
         - a[1],...,a[s-1] the lower dimensional equidimensional loci.
-NOTE:    An embedded component q (primary ideal) of i can be replaced in the
+         If I is the unit ideal, a list containing the unit ideal as a[1] is returned.
+NOTE:    An embedded component q (primary ideal) of I can be replaced in the
          decomposition by a primary ideal q1 with the same radical as q. @*
-         @code{equidim(i,1)} uses the algorithm of Eisenbud/Huneke/Vasconcelos.
+         @code{equidim(I,1)} uses the algorithm of Eisenbud/Huneke/Vasconcelos.
 
 EXAMPLE:example equidim; shows an example
@@ -2405 +2548 @@
       );
   }
-
   intvec op ;
   def  P = basering;
@@ -2635 +2777 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-
-proc algeDeco(ideal i, int w)
-{
+//w=0: GTZ
+//w=1: SY
+//w=2: minAss
+proc algeDecoE(ideal I, int w)
+{//reduces primery decomposition over algebraic extensions to
+//the other cases
+    return( algeDeco_i( int(1), I, int w) );
+}
+
+//w=0: GTZ
+//w=1: SY
+//w=2: minAss
+// deprecated. use 'algeDecoE()'
+proc algeDeco(ideal I, int w)
+{//reduces primery decomposition over algebraic extensions to
+//the other cases
+    return( algeDeco_i(int(0), I, int w));
+}
+
+
+//w=0: GTZ
+//w=1: SY
+//w=2: minAss
+static proc algeDeco_i(int patchPrimaryDecomposition, ideal i, int w)
+{//reduces primery decomposition over algebraic extensions to
+//the other cases
+// if patchPrimaryDecomposition=1,  drop unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
+
    ASSUME(0, hasFieldCoefficient(basering) );
    ASSUME(0, not isQuotientRing(basering) ) ;
@@ -2655 +2823 @@
    if((size(i)==2) && (w==2))
    {
+      //treats a special case separately which would otherwise take a lot longer in factorization
       option( redSB );
       ideal J = std(i);
-      option( noredSB );
+      option( set, op );
+      if(size(J)==1)
+      {
+         if ( deg(lead(J[1]))==0 ) // we have the unit ideal
+         { 
+            if (patchPrimaryDecomposition==1)
+            {
+                return( list() ); 
+            }
+            else
+            {
+                return( list( ideal(1) ) ); 
+            }
+         }
+      }
       if ((size(J)==2)&&(deg(J[1])==1))
       {
+         // minAssPrimes correspond to factorization of J[2]
          ideal keep;
          poly f;
@@ -2722 +2906 @@
    if(w==0)
    {
-      pr=decomp(i);
+      pr=decomp_i(patchPrimaryDecomposition,i);
    }
    if(w==1)
    {
-      pr=prim_dec(i,1);
+      pr=prim_dec_i(patchPrimaryDecomposition,i,1);
       pr=reconvList(pr);
    }
    if(w==2)
    {
-      pr=minAssPrimes(i);
+      pr=minAssPrimes_i(patchPrimaryDecomposition,i);
    }
+
+   int sizepr = size(pr);
 
    if(n<nvars(basering))
@@ -2741 +2927 @@
       R_l[3]=list(list("dp",1:n),list("lp",1:(nvars(basering)-n)),list("C",0));
       def RS=ring(R_l); kill R_l; setring RS;
-      list pr=imap(RH,pr);
+      if (sizepr>0) {    list  pr=imap(RH,pr); ASSUME(1, sizepr == size(pr)); }
       ideal K;
-      for(j=1;j<=size(pr);j++)
+      for(j=1;j<=sizepr;j++)
       {
          K=groebner(pr[j]);
-         K=K[2..size(K)];
+         if (size(K)>1) 
+         {
+             K = K[2..size(K)];
+         } 
          pr[j]=K;
       }
       setring R;
-      list pr=imap(RS,pr);
+      if (sizepr>0) {  list pr=imap(RS,pr); }
    }
    else
    {
       setring R;
-      list pr=imap(RH,pr);
+      if (sizepr>0)  { list pr=imap(RH,pr); }
    }
 
@@ -2788 +2977 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-static proc decomp(ideal i,list #)
-"USAGE:  decomp(i); i ideal  (for primary decomposition)   (resp.
-         decomp(i,1);        (for the associated primes of dimension of i) )
-         decomp(i,2);        (for the minimal associated primes) )
-         decomp(i,3);        (for the absolute primary decomposition) )
+
+static proc decompE(ideal I,list #)
+"USAGE:  decompE(I); I ideal  (for primary decomposition)   (resp.
+         decompE(I,1);        (for the associated primes of dimension of I) )
+         decompE(I,2);        (for the minimal associated primes) )
+         decompE(I,3);        (for the absolute primary decomposition) )
 RETURN:  list = list of primary ideals and their associated primes
          (at even positions in the list)
          (resp. a list of the minimal associated primes)
+         if I is unit ideal, returns emtpy list
 NOTE:    Algorithm of Gianni/Trager/Zacharias
+EXAMPLE: example decompE; shows an example
+"
+{
+    return(decomp_i(int(1),I,#));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring  r = 32003,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z4+2;
+   ideal I = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   list pr= decompE(I);
+   pr;
+   testPrimary( pr, I);
+}
+
+static proc decomp(ideal I,list #)
+"USAGE:  decomp(I); I ideal  (for primary decomposition)   (resp.
+         decomp(I,1);        (for the associated primes of dimension of I) )
+         decomp(I,2);        (for the minimal associated primes) )
+         decomp(I,3);        (for the absolute primary decomposition) )
+RETURN:  list = list of primary ideals and their associated primes
+         (at even positions in the list)
+         (resp. a list of the minimal associated primes)
+         if I is unit ideal, returns list(ideal(1),ideal(1)) ( resp. list(ideal(1)))
+NOTE:    deprecated. Use 'decompE()'
 EXAMPLE: example decomp; shows an example
 "
 {
+    return(decomp_i(int(0),I,#));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring  r = 32003,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z4+2;
+   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   list pr= decomp(i);
+   pr;
+   testPrimary( pr, i);
+}
+
+static proc decomp_i(int patchPrimaryDecomposition, ideal i,list #)
+{
+// if patchPrimaryDecomposition=1,  drop unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
+// for other parameters see 'decomp' or 'decompE'
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
   ASSUME(1, hasGlobalOrdering(basering) ) ;
-
-  intvec op,@vv;
+  intvec initialOp,op,@vv;
+  initialOp = option(get);
   def  @P = basering;
   list primary,indep,ltras;
@@ -2813 +3048 @@
   int isS=(attrib(i,"isSB")==1);
 
-
   if(size(#)>0)
   {
@@ -2845 +3079 @@
       //ltras=mstd(i);
       tras=groebner(i);
-      ltras=tras,tras;
-      attrib(ltras[1],"isSB",1);
     }
     else
-    {
-      ltras=i,i;
-      attrib(ltras[1],"isSB",1);
-    }
+    { 
+      tras=i;
+    }
+    ltras = tras,tras;
+    attrib( ltras[1], "isSB", 1);
+
+    if (size(ltras[1])>0)
+    {
+        if ( deg(lead(ltras[1]))==0 ) // we have the unit ideal.
+        { 
+          option(set,initialOp); 
+          if (patchPrimaryDecomposition==1)
+          {
+             if (abspri) { return(prepare_absprimdec(list()));  } 
+             return( list() ); 
+          }
+          else
+          {
+            primary[1]=ideal(1);
+            primary[2]=ideal(1);
+                if (abspri) { return(prepare_absprimdec(primary));}
+             return( primary ); 
+          }
+        }
+    }
+
     tras=ltras[1];
     attrib(tras,"isSB",1);
@@ -2859 +3113 @@
       primary[1]=ltras[2];
       primary[2]=maxideal(1);
+      option(set,initialOp); 
       if(@wr>0)
       {
@@ -2882 +3137 @@
   if(size(i)==0)
   {
+    option(set,initialOp); 
     primary=ideal(0),ideal(0);
     if (abspri) { return(prepare_absprimdec(primary));}
@@ -2923 +3179 @@
       ideal @j=groebner(fetch(@P,i));
     }
+    if(size(@j)==1)
+    {
+        if ( deg( lead(@j[1]) )==0 ) // we have the unit ideal.
+        { 
+            setring @P;
+            option(set,initialOp);
+            if (patchPrimaryDecomposition==1)
+            {
+                 return( list() ); 
+            }
+            else
+            {
+               return( list(ideal(1),ideal(1)) ); 
+            }
+        }
+    }
   }
   option(set,op);
@@ -2949 +3221 @@
     {
       setring @P;
+      option(set,initialOp);
       primary[1]=i;
       primary[2]=i;
@@ -2990 +3263 @@
       @j=std(@j);
 
-      list pr=decomp(@j);
+      list pr=decomp_i(patchPrimaryDecomposition,@j);
+      if (size(pr)==0)
+      {      
+            setring @P;
+            option(set,initialOp);
+            if (abspri) { return(prepare_absprimdec(list()));}
+            return(list());
+      }
+      
       setring gnir;
       list pr=imap(@deirf,pr);
@@ -2999 +3280 @@
       }
       setring @P;
+      option(set,initialOp);
       primary=imap(gnir,pr);
       if (abspri) { return(prepare_absprimdec(primary));}
@@ -3011 +3293 @@
   {
     setring @P;
+    option(set,initialOp);
     primary=ideal(1),ideal(1);
     if (abspri) { return(prepare_absprimdec(primary));}
@@ -3038 +3321 @@
     }
     setring @P;
+    option(set,initialOp); 
     primary=fetch(gnir,gprimary);
-
 //HIER
+
     if (abspri) { return(prepare_absprimdec(primary));}
     return(primary);
@@ -3099 +3383 @@
       primary=imap(gnir,primary);
     }
-    option(set,op);
+    option(set,initialOp); 
     return(primary);
   }
@@ -3725 +4009 @@
         if(@wr>0)
         {
-          htprimary=decomp(@j,@wr,peek,ser);
+          htprimary=decomp_i(patchPrimaryDecomposition, @j,@wr,peek,ser);
         }
         else
         {
-          htprimary=decomp(@j,peek,ser);
+          htprimary=decomp_i(patchPrimaryDecomposition,@j,peek,ser);
         }
         // here we collect now both results primary(sat(j,gh))
@@ -3760 +4044 @@
   //---------------------------------------------------------------------------
   setring @P;
+  option(set,initialOp); 
   primary=imap(gnir,quprimary);
   if(!abspri)
@@ -3774 +4059 @@
 
 
-example
-{ "EXAMPLE:"; echo = 2;
-   ring  r = 32003,(x,y,z),lp;
-   poly  p = z2+1;
-   poly  q = z4+2;
-   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
-   list pr= decomp(i);
-   pr;
-   testPrimary( pr, i);
-}
+
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -4291 +4567 @@
 //////////////////////////////////////////////////////
 
-
-static proc min_ass_prim_charsets (ideal PS, int cho)
-{
-  if((cho<0) and (cho>1))
+static proc min_ass_prim_charsets_i (int patchPrimaryDecomposition, ideal PS, int cho)
+{
+// if patchPrimaryDecomposition=1,  drop unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
+  ASSUME(1, hasFieldCoefficient(basering) );
+  ASSUME(1, hasGlobalOrdering(basering) ) ;
+  ASSUME(1, not isQuotientRing(basering) ) ;
+
+  if((cho<0) or (cho>1))
   {
     ERROR("<int> must be 0 or 1");
@@ -4303 +4584 @@
   if(cho==0)
   {
-    L=min_ass_prim_charsets0(PS);
+    L=min_ass_prim_charsets0_i(patchPrimaryDecomposition,PS);
   }
   else
   {
-    L=min_ass_prim_charsets1(PS);
+    L=min_ass_prim_charsets1_i(patchPrimaryDecomposition,PS);
   }
   option(set,saveopt);
@@ -4321 +4602 @@
 
 
-static proc min_ass_prim_charsets0 (ideal PS)
-{
+static proc min_ass_prim_charsets0_i (int patchPrimaryDecomposition, ideal PS)
+{
+// if patchPrimaryDecomposition=1,  drop unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
@@ -4328 +4611 @@
 
   intvec op;
+  if (size(PS)==0) { return( list(ideal(0))); }
   matrix m=char_series(PS);  // We compute an irreducible
                              // characteristic series
@@ -4334 +4618 @@
   && (m[1,1]==1)) // in case of an empty series: min_ass_prim_charsets1
   {
-    return min_ass_prim_charsets1(PS);
+    return (min_ass_prim_charsets1_i(patchPrimaryDecomposition,PS));
   }
   int i,j,k;
@@ -4412 +4696 @@
     }
   }
+  if(size(PSI)==1)
+  {
+    if (idealsEqual( PSI[1], ideal(1) ))
+    {
+      if (patchPrimaryDecomposition==1)
+      {
+        return( list() ); 
+      }
+      else
+      {
+        return( list(ideal(1)) ); 
+      }
+    }
+  } 
   return (PSI);
 }
@@ -4426 +4724 @@
 
 
-static proc min_ass_prim_charsets1 (ideal PS)
-{
+static proc min_ass_prim_charsets1_i (int patchPrimaryDecomposition, ideal PS)
+{
+// if patchPrimaryDecomposition=1,  drop unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
@@ -4434 +4734 @@
   intvec op;
   def oldring=basering;
+  if (size(PS)==0) { return( list(ideal(0))); }
   string n=system("neworder",PS);
   execute("ring r=("+charstr(oldring)+"),("+n+"),dp;");
@@ -4466 +4767 @@
       I=I,ini_mod(PHI[i][j]);
     }
-    I=I[2..ncols(I)];
+    if (ncols(I)>1)
+    {
+      I=I[2..ncols(I)];
+    }
     ITPHI[i]=I;
   }
@@ -4544 +4848 @@
     }
   }
+  if(size(PSI)==1)
+  {
+    if (idealsEqual( PSI[1], ideal(1) ))
+    {
+      if (patchPrimaryDecomposition==1)
+      {
+        return( list() ); 
+      }
+      else
+      {
+        return( list(ideal(1)) ); 
+      }
+    }
+  } 
+
   return (PSI);
 }
@@ -4568 +4887 @@
 //////////////////////////////////////////////////////////
 
-
-static proc prim_dec(ideal I, int choose)
-{
+static proc prim_dec_i(int patchPrimaryDecomposition, ideal I, int choose)
+{
+// if patchPrimaryDecomposition=1,  drop unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
   ASSUME(1, hasGlobalOrdering(basering) ) ;
-
   if((choose<0) or (choose>3))
   {
@@ -4608 +4927 @@
   if(SI[1]==1)  // primdecSY(ideal(1))
   {
-    return(list());
+          ASSUME(1, ncols(SI)==1);
+          if (patchPrimaryDecomposition==1)
+          {
+             return( list() ); 
+          }
+          else
+          {
+               return( list(list(ideal(1),ideal(1))) ); 
+          }
   }
   intvec save=option(get);
@@ -4712 +5039 @@
       if (V[2]==3) // pseudo_prim_dec_special is needed
       {
-        QQ,SRest=pseudo_prim_dec_special_charsets(V[1],V[6],choose);
+        QQ,SRest=pseudo_prim_dec_special_charsets_i(patchPrimaryDecomposition,V[1],V[6],choose);
                          // QQ = quadruples:
                          // standard basis of pseudo-primary component,
@@ -4723 +5050 @@
       else     // V is the root, pseudo_prim_dec is needed
       {
-        QQ,SRest=pseudo_prim_dec_charsets(I,SI,choose);
+        QQ,SRest=pseudo_prim_dec_charsets_i(patchPrimaryDecomposition,I,SI,choose);
                          // QQ = quadruples:
                          // standard basis of pseudo-primary component,
@@ -4796 +5123 @@
 
 
-static proc pseudo_prim_dec_charsets (ideal I, ideal SI, int choo)
-{
+static proc pseudo_prim_dec_charsets_i(int patchPrimaryDecomposition, ideal I, ideal SI, int choo)
+{
+// if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
@@ -4806 +5135 @@
   if((choo==0) or (choo==1))
   {
-    L=min_ass_prim_charsets(I,choo);
+    L=min_ass_prim_charsets_i(patchPrimaryDecomposition,I,choo);
   }
   else
@@ -4812 +5141 @@
     if(choo==2)
     {
-      L=minAssPrimes(I);
+      L=minAssPrimes_i(patchPrimaryDecomposition,I);
     }
     else
     {
-      L=minAssPrimes(I,1);
+      L=minAssPrimes_i(patchPrimaryDecomposition,I,1);
     }
     for(int i=size(L);i>=1;i--)
@@ -4823 +5152 @@
     }
   }
-  return (pseudo_prim_dec_i(SI,L));
+  return (pseudo_prim_dec_i_i(patchPrimaryDecomposition,SI,L));
 }
 
@@ -4849 +5178 @@
 ////////////////////////////////////////////////////////////////
 
-
-static proc pseudo_prim_dec_special_charsets (ideal SI,list V6, int choo)
-{
+static proc pseudo_prim_dec_special_charsets_i (int patchPrimaryDecomposition, ideal SI,list V6, int choo)
+{
+// if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
   ASSUME(1, hasGlobalOrdering(basering) ) ;
-
   int i,j,l;
   list m;
@@ -4875 +5204 @@
         if((choo==0) or (choo==1))
         {
-          m=min_ass_prim_charsets(SP,choo);  // a list of SB
+          m=min_ass_prim_charsets_i(patchPrimaryDecomposition,SP,choo);  // a list of SB
         }
         else
@@ -4881 +5210 @@
           if(choo==2)
           {
-            m=minAssPrimes(SP);
+            m=minAssPrimes_i(patchPrimaryDecomposition,SP);
           }
           else
           {
-            m=minAssPrimes(SP,1);
+            m=minAssPrimes_i(patchPrimaryDecomposition,SP,1);
           }
           for(j=size(m);j>=1;j--)
@@ -4934 +5263 @@
     }
   }
-  return (pseudo_prim_dec_i(SI,L));
+  return (pseudo_prim_dec_i_i(patchPrimaryDecomposition,SI,L));
 }
 
 
 ////////////////////////////////////////////////////////////////
-// proc pseudo_prim_dec_i
+// proc pseudo_prim_dec_i_i
 // input: A standard basis of an arbitrary ideal I, and standard bases
 // of the minimal associated primes of I
@@ -4951 +5280 @@
 ////////////////////////////////////////////////////////////////
 
-
-static proc pseudo_prim_dec_i (ideal SI, list L)
-{
+static proc pseudo_prim_dec_i_i (int patchPrimaryDecomposition, ideal SI, list L)
+{
+// if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+// since the unit ideal it is not prime, otherwise take no special action.
   ASSUME(1, hasFieldCoefficient(basering) );
   ASSUME(1, not isQuotientRing(basering) ) ;
   ASSUME(1, hasGlobalOrdering(basering) ) ;
-
   list Q;
   if (size(L)==1)               // one minimal associated prime only
@@ -5356 +5685 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
-
-proc primdecGTZ(ideal i, list #)
-"USAGE:   primdecGTZ(i); i ideal
-RETURN:  a list pr of primary ideals and their associated primes:
+proc primdecGTZE(ideal I, list #)
+"USAGE:   primdecGTZE(I); i ideal
+RETURN:  a list pr of primary ideals and their associated primes for a proper ideal, and an empty list for the unit ideal.
 @format
    pr[i][1]   the i-th primary component,
@@ -5372 +5700 @@
            corresponding global ring is returned if the string 'global'
            is specified as second argument
+EXAMPLE: example primdecGTZE; shows an example
+"
+{
+    return (primdecGTZ_i(int(1),I,  #));     
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal I = p*q^2,y-z2;
+   list pr = primdecGTZE(I);
+   pr;
+   ideal J = 1;
+   list prempty = primdecGTZE(J);
+   prempty;
+}
+
+proc primdecGTZ(ideal I, list #)
+"USAGE:   primdecGTZ(I); I ideal
+RETURN:  a list pr of primary ideals and their associated primes for a proper ideal I, otherwise pr = list( list( ideal(1), ideal(1) ) 
+@format
+   pr[i][1]   the i-th primary component,
+   pr[i][2]   the i-th prime component.
+@end format
+NOTE:      deprecated. use 'primdecGTZE()'
+         - 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
 "
 {
+    return (primdecGTZ_i(int(0), I , #));
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal i = p*q^2,y-z2;
+   list pr = primdecGTZ(i);
+   pr;
+}
+
+static proc primdecGTZ_i(int patchPrimaryDecomposition,ideal i, list #)
+{
+// if parameter patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+//           since the unit ideal it is not prime, otherwise take no special action.
+// For other parameters see 'primdecGTZ' or 'primdecGTZE'.
    ASSUME(0, hasFieldCoefficient(basering) );
    ASSUME(0, not isQuotientRing(basering) ) ;
@@ -5390 +5769 @@
       ideal i=imap(r,i);
 // decompose and go back
-      list li=primdecGTZ(i);
+      list li=primdecGTZ_i(patchPrimaryDecomposition,i);
+      int sizeli = size(li);
       setring r;
+      if (sizeli==0)  
+      {
+          return ( list() ); 
+      }
       def li=imap(s,li);
 // clean up
@@ -5410 +5794 @@
    if(minpoly!=0)
    {
-      return(algeDeco(i,0));
+      return(algeDeco_i(patchPrimaryDecomposition,i,0));
       ERROR(
       "// Not implemented yet for algebraic extensions.Simulate the ring extension by adding the minpoly to the ideal"
       );
    }
-  return(convList(decomp(i)));
+  return(convList(decomp_i(patchPrimaryDecomposition,i)));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+proc absPrimdecGTZE(ideal I, list #)
+"USAGE:   absPrimdecGTZE(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)}. Will fail for unit ideal.
+         The list absolute_primes has to be interpreted as follows:
+         each entry describes a class of conjugated absolute primes,
+@format
+   absolute_primes[i][1]   the absolute prime component,
+   absolute_primes[i][2]   the number of conjugates.
+@end format
+         The first entry of @code{absolute_primes[i][1]} is the minimal
+         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.
+SEE ALSO: primdecGTZ; absFactorize
+EXAMPLE: example absPrimdecGTZE; shows an example
+"
+{
+     return(absPrimdecGTZ_i(int(1),I,#));
 }
 example
@@ -5422 +5836 @@
    poly  p = z2+1;
    poly  q = z3+2;
-   ideal i = p*q^2,y-z2;
-   list pr = primdecGTZ(i);
-   pr;
-}
-///////////////////////////////////////////////////////////////////////////////
+   ideal I = p*q^2,y-z2;
+   def S = absPrimdecGTZE(I);
+   setring S;
+   absolute_primes;
+}
+
 proc absPrimdecGTZ(ideal I, list #)
 "USAGE:   absPrimdecGTZ(I); I ideal
@@ -5447 +5862 @@
          corresponding global ring is returned if the string 'global'
          is specified as second argument
-NOTE:    Algorithm of Gianni/Trager/Zacharias combined with the
+NOTE:    deprecated. Use 'absPrimdecGTZE()'.
+         Algorithm of Gianni/Trager/Zacharias combined with the
          @code{absFactorize} command.
 SEE ALSO: primdecGTZ; absFactorize
@@ -5453 +5869 @@
 "
 {
+ 
+    return(absPrimdecGTZ_i(int(0),I,#));
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal i = p*q^2,y-z2;
+   def S = absPrimdecGTZ(i);
+   setring S;
+   absolute_primes;
+}
+
+
+
+static proc absPrimdecGTZ_i(int patchPrimaryDecomposition, ideal I, list #)
+{
+// if parameter patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+//           since the unit ideal it is not prime, otherwise take no special action.
+// For other parameters see 'absPrimdecGTZ' or 'absPrimdecGTZE'.
   ASSUME(0, hasFieldCoefficient(basering) );
   ASSUME(0, not isQuotientRing(basering) ) ;
@@ -5475 +5912 @@
       setring s;
       def I=imap(r,I);
-      def S=absPrimdecGTZ(I);
+      def S=absPrimdecGTZ_i(patchPrimaryDecomposition,I);
       setring S;
       ring r1=char(basering),var(nvars(r)+1),dp;
@@ -5514 +5951 @@
   if(minpoly!=0)
   {
-    //return(algeDeco(i,0));
+    //return(algeDeco_i(patchPrimaryDecomposition,I,0));
     ERROR(
       "// Not implemented yet for algebraic extensions.Simulate the ring extension by adding the minpoly to the ideal"
@@ -5521 +5958 @@
   def R=basering;
   int n=nvars(R);
-  list L=decomp(I,3);
+  list L=decomp_i(patchPrimaryDecomposition,I,3);
+  if (patchPrimaryDecomposition && size(L)==0 ) 
+  {
+     ERROR("will not handle case with unit ideal");
+  }
   string newvar=L[1][3];
   int k=find(newvar,",",find(newvar,",")+1);
@@ -5578 +6019 @@
   export(absolute_primes);
   setring R;
-  dbprint( printlevel-voice+3,"
+  dbprint( printlevel-voice+4,"
 // 'absPrimdecGTZ' created a ring, in which two lists absolute_primes (the
 // absolute prime components) and primary_decomp (the primary and prime
@@ -5588 +6029 @@
   return(Rz);
 }
-example
-{ "EXAMPLE:";  echo = 2;
-   ring  r = 0,(x,y,z),lp;
-   poly  p = z2+1;
-   poly  q = z3+2;
-   ideal i = p*q^2,y-z2;
-   def S = absPrimdecGTZ(i);
-   setring S;
-   absolute_primes;
-}
+
 
 ///////////////////////////////////////////////////////////////////////////////
-
-proc primdecSY(ideal i, list #)
-"USAGE:   primdecSY(I, c); I ideal, c int (optional)
+proc primdecSYE(ideal I, list #)
+"USAGE:   primdecSYE(I, c); I ideal, c int (optional)
 RETURN:  a list pr of primary ideals and their associated primes:
 @format
@@ -5608 +6039 @@
    pr[i][2]   the i-th prime component.
 @end format
+If I is the unit ideal returns an empty list.
 NOTE:    Algorithm of Shimoyama/Yokoyama.
 @format
@@ -5623 +6055 @@
 "
 {
+     return (primdecSY_i(int(1),I,#));
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal I = p*q^2,y-z2;
+   list pr = primdecSYE(I);
+   pr;
+   ideal J = x;
+   list prUnit = primdecSYE(J);
+   prUnit;
+}
+
+proc primdecSY( ideal I, list #)
+"USAGE:   primdecSY(I, c); I ideal, c int (optional)
+RETURN:  a list pr of primary ideals and their associated primes for proper ideal I, otherwise pr[1] is list( ideal(1),ideal(1) )'
+@format
+   pr[i][1]   the i-th primary component,
+   pr[i][2]   the i-th prime component.
+@end format
+NOTE:    deprecated. Use 'primdecSYE()'.
+         Algorithm of Shimoyama/Yokoyama.
+@format
+   if c=0,  the given ordering of the variables is used,
+   if c=1,  minAssChar tries to use an optimal ordering (default),
+   if c=2,  minAssGTZ is used,
+   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
+"
+{
+    return (primdecSY_i(int(0),I,#));
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),lp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal i = p*q^2,y-z2;
+   list pr = primdecSY(i);
+   pr;
+}
+
+
+static proc primdecSY_i(int patchPrimaryDecomposition, ideal i, list #)
+{
+//           if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+//           since the unit ideal it is not prime, otherwise take no special action.
+//           For other paremetes see 'primdecSY' or 'primdecSYE'
    ASSUME(0, hasFieldCoefficient(basering) );
    ASSUME(0, not isQuotientRing(basering) ) ;
@@ -5638 +6126 @@
       ideal i=imap(r,i);
 // decompose and go back
-      list li=primdecSY(i);
+      list li=primdecSY_i(patchPrimaryDecomposition,i);
+      int sizeli = size(li);
       setring r;
+      if (sizeli==0)  { return ( list() ); }
       def li=imap(s,li);
 // clean up
@@ -5656 +6146 @@
    }
    i=simplify(i,2);
-   if ((i[1]==0)||(i[1]==1))
+
+   //if ((i[1]==0)||(i[1]==1)) // would not work anyway, since i cannot be assumed to be in standard basis form; 
+   //                          // but why return list(1,1) in case i=1 ??
+   if ( (i[1]==0) )
+
    {
-     list L=list(ideal(i[1]),ideal(i[1]));
+     list L = list(ideal(i[1]), ideal(i[1]) );
      return(list(L));
    }
@@ -5664 +6158 @@
    if(minpoly!=0)
    {
-      return(algeDeco(i,1));
+      return(algeDeco_i(patchPrimaryDecomposition,i,1));
    }
    if (size(#)!=0)
-   { return(prim_dec(i,#[1])); }
+   { return(prim_dec_i(patchPrimaryDecomposition,i,#[1])); }
    else
-   { return(prim_dec(i,1)); }
-}
-example
-{ "EXAMPLE:";  echo = 2;
-   ring  r = 0,(x,y,z),lp;
-   poly  p = z2+1;
-   poly  q = z3+2;
-   ideal i = p*q^2,y-z2;
-   list pr = primdecSY(i);
-   pr;
-}
-///////////////////////////////////////////////////////////////////////////////
-proc minAssGTZ(ideal i,list #)
-"USAGE:    minAssGTZ(I[, l]); I ideal, l list (optional)
+   { return(prim_dec_i(patchPrimaryDecomposition,i,1)); }
+}
+
+
+
+proc minAssGTZE(ideal I,list #)
+"USAGE:    minAssGTZE(I[, l]); I ideal, l list (optional)
    @* Optional parameters in list l (can be entered in any order):
    @* 0, \"facstd\" -> uses facstd to first decompose the ideal (default)
@@ -5697 +6184 @@
            corresponding global ring is returned if the string 'global'
            is specified as second argument
+EXAMPLE: example minAssGTZE; shows an example
+"
+{
+    list result = minAssGTZ_i(int(1),I,#);
+    return(result);
+     
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),dp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal I = p*q^2,y-z2;
+   list pr = minAssGTZE(I);
+   pr;
+   ideal J = 1;
+   list prempty = minAssGTZE(J);
+   prempty;
+
+}
+
+
+proc minAssGTZ(ideal I,list #)
+"USAGE:    minAssGTZ(I[, l]); I ideal, l list (optional)
+   @* Optional parameters in list l (can be entered in any order):
+   @* 0, \"facstd\" -> uses facstd to first decompose the ideal (default)
+   @* 1, \"noFacstd\" -> does not use facstd
+   @* \"GTZ\" -> the original algorithm by Gianni, Trager and Zacharias is used
+   @* \"SL\" -> GTZ algorithm with modificiations by Laplagne is used (default)
+
+RETURN:  a list, the minimal associated prime ideals of proper ideal I, otherwise ideal(1)
+NOTE:    deprecated. Use 'minAssGTZE()'.
+         - 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
 "
 {
+    list result = minAssGTZ_i(int(0),I,#);
+    return(result);
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),dp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal i = p*q^2,y-z2;
+   list pr = minAssGTZ(i);
+   pr;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+static proc minAssGTZ_i(int patchPrimaryDecomposition, ideal i,list #)
+ {
+//           if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+//           since the unit ideal it is not prime, otherwise take no special action.
+//           For other parameters see 'minAssGTZ' or 'minAssGTZE'
    ASSUME(0, hasFieldCoefficient(basering) );
    ASSUME(0, not isQuotientRing(basering) ) ;
@@ -5716 +6262 @@
       ideal i=imap(r,i);
 // decompose and go back
-      list li=minAssGTZ(i);
+      list li=minAssGTZ_i(patchPrimaryDecomposition,i);
+      int sizeli = size(li);
       setring r;
+      if (sizeli==0) { return(list()); }
       def li=imap(s,li);
 // clean up
@@ -5775 +6323 @@
   if(minpoly!=0)
   {
-    return(algeDeco(i,2));
-  }
-
-  list result = minAssPrimes(i, facstdOption, algorithm);
+    return(algeDeco_i(patchPrimaryDecomposition,i,2));
+  }
+
+  list result = minAssPrimes_i(patchPrimaryDecomposition,i, facstdOption, algorithm);
   return(result);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+proc minAssCharE(ideal I, list #)
+"USAGE:   minAssCharE(I[,c]); i ideal, c int (optional).
+RETURN:  list, the minimal associated prime ideals of I. If I is the unit ideal returns an empty list.
+NOTE:    If c=0, the given ordering of the variables is used. @*
+         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 minAssCharE; shows an example
+"
+{
+    return(minAssChar_i(int(1),I,#));
 }
 example
@@ -5786 +6353 @@
    poly  p = z2+1;
    poly  q = z3+2;
-   ideal i = p*q^2,y-z2;
-   list pr = minAssGTZ(i);
+   ideal I = p*q^2,y-z2;
+   list pr = minAssCharE(I);
    pr;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-proc minAssChar(ideal i, list #)
+   ideal J = 5;
+   list prempty = minAssCharE(J);
+   prempty;
+}
+
+proc minAssChar(ideal I, list #)
 "USAGE:   minAssChar(I[,c]); i ideal, c int (optional).
-RETURN:  list, the minimal associated prime ideals of i.
-NOTE:    If c=0, the given ordering of the variables is used. @*
+RETURN:  list, the minimal associated prime ideals of I. If I is the unit ideal returns list( ideal(1) )
+NOTE:    deprecated. Use 'minAssCharE'.
+         If c=0, the given ordering of the variables is used. @*
          Otherwise, the system tries to find an optimal ordering,
          which in some cases may considerably speed up the algorithm. @*
@@ -5805 +6375 @@
 EXAMPLE: example minAssChar; shows an example
 "
-{
+{  
+    return(minAssChar_i(int(0),I,#));
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0,(x,y,z),dp;
+   poly  p = z2+1;
+   poly  q = z3+2;
+   ideal i = p*q^2,y-z2;
+   list pr = minAssChar(i);
+   pr;
+}
+
+proc minAssChar_i(int patchPrimaryDecomposition, ideal i, list #)
+{
+//           if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+//           since the unit ideal it is not prime, otherwise take no special action.
+//           For other parameters see 'minAssChar' or 'minAssCharE'
    ASSUME(0, hasFieldCoefficient(basering) );
    ASSUME(0, not isQuotientRing(basering) ) ;
+   ASSUME(0,size(#)<3);
    if(size(#)>1)
    {
@@ -5821 +6409 @@
       ideal i=imap(r,i);
 // decompose and go back
-      list li=minAssChar(i);
+      list li=minAssChar_i(patchPrimaryDecomposition,i);
+      int sizeli = size(li);
       setring r;
+      if (sizeli==0) { return(list()); }
       def li=imap(s,li);
 // clean up
@@ -5839 +6429 @@
    }
    if (size(#)>0)
-   { return(min_ass_prim_charsets(i,#[1])); }
+   { return(min_ass_prim_charsets_i(patchPrimaryDecomposition,i,#[1])); }
    else
-   { return(min_ass_prim_charsets(i,1)); }
-}
-example
-{ "EXAMPLE:";  echo = 2;
-   ring  r = 0,(x,y,z),dp;
-   poly  p = z2+1;
-   poly  q = z3+2;
-   ideal i = p*q^2,y-z2;
-   list pr = minAssChar(i);
-   pr;
-}
+   { return(min_ass_prim_charsets_i(patchPrimaryDecomposition,i,1)); }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 proc equiRadical(ideal i)
@@ -6479 +7061 @@
 // Given an ideal I and an ideal P (intersection of some minimal prime ideals
 // associated to I), it calculates the intersection of new minimal prime ideals
-// associated to I which where not used to calculate P.
+// associated to I which where not used to calculate P. P = 1 represents empty intersection.
 // This version uses ZD Radical in the zerodimensional case.
 static proc radicalSLIteration (ideal I, ideal P);
@@ -6746 +7328 @@
 }
 
+
+proc testPrimaryE(list pr, ideal k)
+"USAGE:   testPrimaryE(pr,k); pr a list, k an ideal.
+ASSUME:  pr is the result of a primary decomposition and may be empty ( for the unit ideal)
+RETURN:  int, 1 if the intersection of the ideals in pr is k, 0 if not
+EXAMPLE: example testPrimaryE; shows an example
+"
+{
+    return(testPrimary_i(int(1),pr,k));
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 32003,(x,y,z),dp;
+   poly  p = z2+1;
+   poly  q = z4+2;
+   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   list pr = primdecGTZ(i);
+   testPrimaryE(pr,i);
+}
+
 proc testPrimary(list pr, ideal k)
 "USAGE:   testPrimary(pr,k); pr a list, k an ideal.
 ASSUME:  pr is the result of primdecGTZ(k) or primdecSY(k).
 RETURN:  int, 1 if the intersection of the ideals in pr is k, 0 if not
+NOTE:    deprecated. Use 'testPrimaryE()'
 EXAMPLE: example testPrimary; shows an example
 "
 {
-   ASSUME(0, hasFieldCoefficient(basering) );
-   ASSUME(0, not isQuotientRing(basering) ) ;
-
-   int i;
-   pr=reconvList(pr);
-   ideal j=pr[1];
-   for (i=2;i<=size(pr) div 2;i++)
-   {
-       j=intersect(j,pr[2*i-1]);
-   }
-   return(idealsEqual(j,k));
+    return(testPrimary_i(int(0),pr,k));
 }
 example
@@ -6774 +7367 @@
    testPrimary(pr,i);
 }
+
+
+static proc testPrimary_i(int patchPrimaryDecomposition,list pr, ideal k)
+{
+//           if patchPrimaryDecomposition=1,  handle the case of an empty decomposition list.
+//           For other parameters see 'testPrimary'
+   ASSUME(0, hasFieldCoefficient(basering) );
+   ASSUME(0, not isQuotientRing(basering) ) ;
+
+   int i;
+   pr=reconvList(pr);
+   if (patchPrimaryDecomposition==1)
+   {
+       if (idealsEqual( k, ideal(1)) )
+       {
+          return( size(pr)==0 ); //list expected to be empty.
+       }
+   }
+   ideal j=pr[1];
+  
+
+   for (i=2;i<=size(pr) div 2;i++)
+   {
+       j=intersect(j,pr[2*i-1]);
+   }
+   return(idealsEqual(j,k));
+}
+
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -6790 +7411 @@
   ASSUME(0, hasFieldCoefficient(basering) );
   ASSUME(0, not isQuotientRing(basering) ) ;
+  ASSUME(2, dim(groebner(I))==1 );
   if(attrib(basering,"global")!=1)
   {
@@ -6892 +7514 @@
    pr;
 }
+
+
+static proc newDecompStepE(ideal I, list #)
+{
+   return(newDecompStep_i(int(1),I,#));
+}
+
+static proc newDecompStep(ideal I, list #)
+{
+    return(newDecompStep_i(int(0),I,#));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
-static proc newDecompStep(ideal i, list #)
-"USAGE:  newDecompStep(i); i ideal  (for primary decomposition)
-         newDecompStep(i,1);        (for the associated primes of dimension of i)
-         newDecompStep(i,2);        (for the minimal associated primes)
-         newDecompStep(i,3);        (for the absolute primary decomposition (not tested!))
+static proc newDecompStep_i(int patchPrimaryDecomposition, ideal i, list #)
+"USAGE:  newDecompStep_i(patchPrimaryDecomposition, I); I ideal  (for primary decomposition)
+         newDecompStep_i(patchPrimaryDecomposition, I,1);        (for the associated primes of dimension of i)
+         newDecompStep_i(patchPrimaryDecomposition, I,2);        (for the minimal associated primes)
+         newDecompStep_i(patchPrimaryDecomposition, I,3);        (for the absolute primary decomposition (not tested!))
          "oneIndep";        (for using only one max indep set)
          "intersect";        (returns alse the intersection of the components founded)
@@ -6905 +7539 @@
          (resp. a list of the minimal associated primes)
 NOTE:    Algorithm of Gianni/Trager/Zacharias
+         if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+         since the unit ideal it is not prime, otherwise take no special action.
 EXAMPLE: example newDecompStep; shows an example
 "
@@ -7145 +7781 @@
       @j=simplify(@j, 2);
       attrib(@j,"isSB",1);
-      result = newDecompStep(@j, indepOption, intersectOption, @wr);
+      result = newDecompStep_i(patchPrimaryDecomposition, @j, indepOption, intersectOption, @wr);
       if (intersectOption == "intersect")
       {
@@ -7753 +8389 @@
            {
               // The following line was dropped to avoid the recursion step:
-              //htprimary=newDecompStep(@j,@wr,peek,ser);
+              //htprimary=newDecompStep_i(patchPrimaryDecomposition, @j,@wr,peek,ser);
               htprimary = list();
            }
@@ -7759 +8395 @@
            {
               // The following line was dropped to avoid the recursion step:
-              //htprimary=newDecompStep(@j,peek,ser);
+              //htprimary=newDecompStep_i(patchPrimaryDecomposition,@j,peek,ser);
               htprimary = list();
            }
@@ -7810 +8446 @@
    poly  p = z2+1;
    poly  q = z4+2;
-   ideal i = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
-   list pr= newDecompStep(i);
+   ideal I = p^2*q^3,(y-z3)^3,(x-yz+z4)^4;
+   int patchDecomposition = 1;
+   list pr = newDecompStep_i(patchDecomposition, I);
    pr;
-   testPrimary( pr, i);
+   testPrimary( pr, I);
 }
 
@@ -8090 +8727 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Based on minAssGTZ
-
-proc minAss(ideal i,list #)
-"USAGE:   minAss(I[, l]); i ideal, l list (optional) of parameters, same as minAssGTZ
+proc minAssE(ideal I,list #)
+"USAGE:   minAssE(I[, l]); I ideal, l list (optional) of parameters, same as minAssGTZ
 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
+EXAMPLE: example minAssE; shows an example
+"
+{
+ return(minAss_i(int(1),I,#));
+}
+example
+{ "EXAMPLE:";  echo = 2;
+   ring  r = 0, (x, y, z), dp;
+   poly  p = z2 + 1;
+   poly  q = z3 + 2;
+   ideal i = p * q^2, y - z2;
+   list pr = minAssE(i);
+   pr;
+   ideal j = 1;
+   list prempty = minAssE(j);
+   prempty;
+}
+
+proc minAss(ideal I,list #)
+"USAGE:   minAss(I[, l]); I ideal, l list (optional) of parameters, same as minAssGTZ
+RETURN:  a list, the minimal associated prime ideals of I. If I is the unit ideal, returns list(ideal(1));
+NOTE:    deprecated. Use 'minAssE()'.
+         Designed for characteristic 0, works also in char k > 0 based
+         on an algorithm of Yokoyama
 EXAMPLE: example minAss; shows an example
 "
 {
-  return(minAssGTZ(i,#));
+    return(minAss_i(int(0),I,#));
 }
 example
@@ -8111 +8771 @@
 }
 
+static proc minAss_i(int patchPrimaryDecomposition,ideal I,list #)
+{
+//         if patchPrimaryDecomposition=1,  drop the unit ideal in the decomposition, 
+//         since the unit ideal it is not prime, otherwise take no special action.
+//         For other parameters see 'minAss' or 'minAssE'
+  return(minAssGTZ_i(patchPrimaryDecomposition,I,#));
+}
+
+
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -8165 +8834 @@
 // Given an ideal I and an ideal P (intersection of some minimal prime ideals
 // associated to I), it calculates new minimal prime ideals associated to I
-// which were not used to calculate P.
+// which were not used to calculate P. P = 1 represents empty intersetion.
 // This version uses Primary Decomposition in the zerodimensional case.
 static proc minAssSLIteration(ideal I, ideal P);
@@ -8199 +8868 @@
   dbprint(printlevel - voice, "// We do the reduction to the zerodimensional case, via decomp.");
 
-  primaryDec = newDecompStep(J, "oneIndep", "intersect", 2);
+  primaryDec = newDecompStep_i( int(1), J, "oneIndep", "intersect", 2);
   // Debug
   dbprint(printlevel - voice, "// Proc decomp has found", size(primaryDec) div 2, "new primary components.");
@@ -8349 +9018 @@
   if (dim(j)>0)
   {
+    ERROR("dim(j)>0 . Please send the failing example to the authors");
     primary[1]=ideal(1);
     primary[2]=ideal(1);
@@ -8404 +9074 @@
     if((size(ser)>0)&&(size(reduce(ser,j,1))==0))
     {
+       ERROR("dim(j)==-1 unexpected. Please send the failing example to the authors");
       primary[1]=ideal(1);
       primary[2]=ideal(1);
@@ -8410 +9081 @@
     if(dim(j)==-1)
     {
+      ERROR("dim(j)==-1 unexpected. Please send the failing example to the authors");
       primary[1]=ideal(1);
       primary[2]=ideal(1);
@@ -8428 +9100 @@
   else
   {
+    ERROR("failure in newZero_decomp. Please send the failing example to the authors");
     primary[1]=ideal(1);
     primary[2]=ideal(1);
@@ -8439 +9112 @@
     if(size(#)>1)
     {
+      ERROR("failure in newZero_decomp. Please send the failing example to the authors");
       primary[1]=ideal(1);
       primary[2]=ideal(1);
@@ -8492 +9166 @@
   }
 
-  if((voice>=6)&&(char(basering)<=181))
+  if((voice>=7)&&(char(basering)<=181))
   {
     primary=splitCharp(primary);
   }
 
-  if((@wr==2)&&(npars(basering)>0)&&(voice>=6)&&(char(basering)>0))
+  if((@wr==2)&&(npars(basering)>0)&&(voice>=7)&&(char(basering)>0))
   {
   //the prime decomposition of Yokoyama in characteristic p
@@ -8507 +9181 @@
       if(size(primary[2*@k])==0)
       {
-        ek=insepDecomp(primary[2*@k-1]);
+        ek=insepDecomp_i(int(1), primary[2*@k-1]);
         primary=delete(primary,2*@k);
         primary=delete(primary,2*@k-1);

Singular/LIB/ring.lib

@@ -33 +33 @@
  isQuotientRing(rng)      ring is a qotient ring
  isSubModule(I,J)         check if I is in J as submodule
+
+ changeordTo(r,o)         change the ordering of a ring to a simple one
+ addvarsTo(r,vars,i)      add variables to a ring
+ addNvarsTo(r,N,name,i)   add N variables to a ring
 ";
 
@@ -1113 +1117 @@
 
 proc changeordTo(def r,string o)
+"USAGE:  changeordTo(ring, string s);
+RETURN:  a ring with the oderinging changed to the (simple) ordering s
+EXAMPLE: example changeordTo(); shows an example
+"
 {
   list rl=ringlist(r);
@@ -1121 +1129 @@
 example
 {
+  "EXAMPLE:"; echo = 2;
   ring r=0,(x,y),lp;
-  def rr=changeordToCdp(r,"dp");
+  def rr=changeordTo(r,"dp");
   rr;
 }
 
+proc addvarsTo(def r,list vars,int blockorder)
+"USAGE:  addvarsTo(ring,list_of_strings, int);
+         int may be: 0:ordering: dp
+                     1:ordering dp,dp
+                     2:oring.ordering,dp
+RETURN:  a ring with the addtional variables
+EXAMPLE: example addvarsTo(); shows an example
+"
+{
+  list rl=ringlist(r);
+  int n=nvars(r);
+  rl[2]=rl[2]+vars;
+  if (blockorder==0)
+  {
+    rl[3]=list(list("C",0),list("dp",1:(nvars(r)+size(vars))));
+  }
+  else
+  {
+    if (blockorder==2)
+    {
+      rl[3]=rl[3]+list(list("dp",1:size(vars)));
+    }
+    else
+    {
+      rl[3]=list(list("C",0),list("dp",1:nvars(r)),list("dp",1:size(vars)));
+    }
+  }
+  def rr=ring(rl);
+  return(rr);
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),lp;
+  def rr=addvarsTo(r,list("a","b"),0);
+  rr; kill rr;
+  def rr=addvarsTo(r,list("a","b"),1);
+  rr; kill rr;
+  def rr=addvarsTo(r,list("a","b"),2);
+  rr;
+}
+proc addNvarsTo(def r,int N,string n,int blockorder)
+"USAGE:  addNvarsTo(ring,int N, string name, int b);
+         b may be: 0:ordering: dp
+                   1:ordering dp,dp
+                   2:oring.ordering,dp
+RETURN:  a ring with N addtional variables
+EXAMPLE: example addNvarsTo(); shows an example
+"
+{
+  list v;
+  for(int i=N;i>0;i--) { v[i]=n+"("+string(i)+")"; }
+  return(addvarsTo(r,v,blockorder));
+}
+example
+{
+  "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),lp;
+  def rr=addNvarsTo(r,2,"@",0);
+  rr; kill rr;
+  def rr=addNvarsTo(r,2,"@",1);
+  rr; kill rr;
+  def rr=addNvarsTo(r,2,"@",2);
+  rr;
+}

Singular/LIB/rinvar.lib

@@ -34 +34 @@
 LIB "elim.lib";
 LIB "zeroset.lib";
+LIB "ring.lib";
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -286 +287 @@
   int i, dbPrt, nrNewVars;
   intvec wt, wth, hs1;
-  string ringSTR1, ringSTR2, order;
-
   def RARB = basering;
-  nrNewVars = size(F);
+  nrNewVars = ncols(F);
 
   dbPrt = printlevel-voice+2;
@@ -299 +298 @@
 
   string @mPoly = string(minpoly);
-  order = "(dp(" + string(nvars(basering)) + "), dp);";
-  ringSTR1 = "ring RAR1 = (" + charstr(basering) + "), (" + varstr(basering) + ", Y(1.." + string(nrNewVars) + ")), " + order;
-  ringSTR2 = "ring RAR2 = (" + charstr(basering) + "), Y(1.." + string(nrNewVars) + "), dp;";
-  execute(ringSTR1);
-  execute("minpoly = number(" + @mPoly + ");");
+  def RAR1=addNvarsTo(basering,nrNewVars,"Y",1); setring RAR1;
+  string ringSTR2 = "ring RAR2 = (" + charstr(basering) + "), Y(1.." + string(nrNewVars) + "), dp;";
 
   ideal I, J1, J2, Fm;

Singular/LIB/sagbi.lib

@@ -31 +31 @@
 LIB "toric.lib";
 LIB "algebra.lib";
+LIB "ring.lib";
 //////////////////////////////////////////////////////////////////////////////
 
@@ -1111 +1112 @@
 
     //------------- change the basering bsr to bsr[@(0),...,@(z)] ----------
-    execute("ring s=("+charstr(basering)+"),("+varstr(basering)+",@(0..z)),dp;");
+    def s=addNvarsTo(basering,z+1,,"@",0); setring s;
     // Ev hier die Reihenfolge der Vars aendern. Dazu muss unten aber entsprechend
     // geaendert werden:

Singular/LIB/solve.lib

@@ -23 +23 @@
 
 LIB "triang.lib";    // needed for triang_solve
+LIB "ring.lib";      // needed for changeordTo
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -692 +693 @@
     if (sb==0)
     {
-      execute("ring dphom=("+charstr(rin)+"),("+
-      varstr(rin)+"),dp;");
+      def dphom=changeordTo(rin,"dp"); setring dphom;
       ideal G = std(imap(rin,G));
       if (dim(G)!=0){ERROR("ideal not zero-dimensional");}
@@ -736 +736 @@
     if (sb==0)
     {
-      execute("ring dphilb=("+charstr(rin)+"),("+ varstr(rin)+"),dp;");
+      def dphilb=changeordTo(rin,"dp"); setring dphilb;
       ideal G = imap(rin,G);
       G = std(G);
@@ -747 +747 @@
       attrib(G,"isSB",1);
     }
-    execute("ring lexhilb=("+charstr(rin)+"),("+ varstr(rin)+"),lp;");
+    def lexhilb=changeordTo(rin,"lp"); setring lexhilb;
     option(redTail);
     ideal H = fglm(dphilb,G);
@@ -755 +755 @@
     else
     {
-      execute("ring lplex=("+charstr(rin)+"),("+varstr(rin)+"),lp;");
+      def lplex=changeordTo(rin,"lp"); setring lplex;
     }
     ideal H = imap(lexhilb,H);

Singular/subexpr.cc

@@ -1807 +1807 @@
     else
     {
-      sleftv tmp;
+      sleftv tmp; tmp.Init();
       int toktype=iiTokType(d->op);
       if ((toktype==CMD_M)

Tst/Short.lst

@@ -275 +275 @@
 Short/string.tst
 Short/test_c_dp.tst
+Short/test_unit_ideal_decomposition.tst
+Short/test_zero_ideal_decomposition.tst
 Short/triang_s.tst
 ; Short/tropical.tst ;; too long ?

Tst/Short/bug_529.res.gz.uu

@@ -1 @@
-begin 640 bug_529.res.gz
-M'XL("-2^1U0``V)U9U\U,CDN<F5S`'5276O",!1][Z^XZ!X2UU53=7YA<9LO
-MA3$$!SZ(2&VC9-.T)I&5C?WW7:NV=6R!)">Y'^?<Y$Y?Q_X+`#`/GOU'J!AM
-MG*U850;6]&QQ/<#+I9#"$#JPCCMX'JP.FV7;[3F2?SC:!";W;WJ0XY8#<6)$
-M+,E'H"0MDK8S.E))E-A%/,PH2^;[4HZ.`XF*0]@)^:#U!`.XGI&(K\&GN5/7
-M@:_\T'-P`<7-04DR.3'T^^5XXE.@D/,QYL!W?G`+<M8\DV.58Q[&NV1J>#(C
-M(N+!%H0-6Z$-5',=K%72P=I_ZKA*17R[>BVE4Y;2+4G!JI20&U`XAZ1!;9*&
-M=KJQTSW"*"%-:C\53^@V/#BI]&$(Z1X]"QM^]J^"?(RLUZ%6`R%#Q0/-S]$,
-M[CQP\18N8ZT$C^9:?'*207K+%L/1VWSTOAA8<[;H6^BT1#!,]R?H(MQ8N/UG
-MNNC"E[_^Y0X=@)4%L-RIU%]NT5\RONXPMWUJVV-K'C1AF.C&^@%^+>\)[0(`
-!````
+begin 644 bug_529.res.gz
+M'XL(",S/5U0``V)U9U\U,CDN<F5S`'526VO",!1^[Z\XZ!X2UU53[;QA<9LO
+MA3$$!SZ(B+91LFE:D\C*QO[[CK=>QA9(\B7G\GTG.9/74?`"`,R'Y^`1*D8;
+M9RM6E;XUN5A<'_!R(:0PA/:MXPZ^#ZO#9N&Y74?R#T>;I<G\FSYDN.5`G!@1
+M2_*Q5)+F2;T3':DD2NPB'IXH"^;[0HZV`XF*0]@)^:#U&`.XGI*(KR&@F5/'
+M@:_LT'5P`<7-04DR/C/T>L5X$E"@D/$QYL!W=G!S<M:\D&.5(Q[&NV1B>#(E
+M(N+++0@;MD(;J&8Z6*N@@WE_ZBBE(H%=+4MI%Z5T"E*P*B7D!A3.`6E0FZ2A
+MG6[L=(\P2DB3VD_Y$[H-'\XJ`QA`ND?/W(:?_:N@`"/K=:C50,A0\:7FEV@&
+M=SZX>`O7L5:"1S,M/CDY07K+YH/AVVSX/N];,S;O6>BT0#!(]V?H(MQ8N/UG
+MNNK"ER__<IOVH9R39<Z%/G/S/I-QN=-<[]R^QQ8]:,(PX8WU`\[8'TSU`@``
 `
 end

Tst/Short/bug_529.stat

@@ -1 @@
-1 >> tst_memory_0 :: 1407244027:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:292608
-1 >> tst_memory_1 :: 1407244027:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2326528
-1 >> tst_memory_2 :: 1407244027:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2379776
-1 >> tst_timer_1 :: 1407244027:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2
+1 >> tst_memory_0 :: 1408579461:4.0.0, 32 bit:4.0.0:i686-Linux:vogon.jeltz:259776
+1 >> tst_memory_1 :: 1408579461:4.0.0, 32 bit:4.0.0:i686-Linux:vogon.jeltz:2338816
+1 >> tst_memory_2 :: 1408579461:4.0.0, 32 bit:4.0.0:i686-Linux:vogon.jeltz:2387344
+1 >> tst_timer_1 :: 1408579461:4.0.0, 32 bit:4.0.0:i686-Linux:vogon.jeltz:4

Tst/Short/ok_s.lst

@@ -30 +30 @@
 bug_tr671
 bug_tr679
+bug_tr686
 bug_genus_etc
 facstd

libpolys/coeffs/longrat.cc

@@ -345 +345 @@
   if ( SR_HDL(n) & SR_INT )
   {
-    int nn=SR_TO_INT(n);
-    if ((long)nn==SR_TO_INT(n))
-       term = nn;
-    else
-    {
-        mpz_t dummy;
-        mpz_init_set_si(dummy, SR_TO_INT(n));
-        term = make_cf(dummy);
-    }
+    long nn=SR_TO_INT(n);
+    term = nn;
   }
   else

libpolys/coeffs/rintegers.cc

@@ -161 +161 @@
 number nrzCopy(number a, const coeffs)
 {
+  if (a==NULL) return NULL;
   mpz_ptr erg = (mpz_ptr) omAllocBin(gmp_nrz_bin);
   mpz_init_set(erg, (mpz_ptr) a);

libpolys/polys/clapsing.cc

@@ -154 +154 @@
   if (g == NULL)
   {
-    res= p_Copy (f,r);
-    p_Delete (&f, r);
+    res= f;
     f=p_One (r);
     return res;
@@ -161 +160 @@
   if (f==NULL)
   {
-    res= p_Copy (g,r);
-    p_Delete (&g, r);
+    res= g;
     g=p_One (r);
     return res;
@@ -172 +170 @@
   {
     bool b1=isOn(SW_USE_EZGCD_P);
-    setCharacteristic( rChar(r) );
     F=convSingPFactoryP( f,r );
     G=convSingPFactoryP( g,r );