Changeset a770fe in git

Timestamp:

May 20, 2014, 5:57:06 PM (9 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

a85671c689d223ccf164d4b692b911272a43935e

Parents:

92550d1a103eaa2a9516fa2d6b6217676a4d17e25b8768586a9b9e826e21175b8c9e94a66c8d205f

Message:

Merge pull request #585 from steenpass/modstd_sw

base modstd.lib on modular.lib

Files:

• Singular/LIB/assprimeszerodim.lib (modified) (3 diffs)
• Singular/LIB/modstd.lib (modified) (6 diffs)
• Singular/LIB/modular.lib (modified) (4 diffs)
• Singular/LIB/primdec.lib (modified) (3 diffs)
• Tst/Long/modstd_l.res.gz.uu (added)
• Tst/Long/modstd_l.stat (added)
• Tst/Long/modstd_l.tst (added)
• Tst/Long/ok_l.lst (modified) (1 diff)
• Tst/Manual.lst (modified) (2 diffs)
• Tst/Manual/all.lst (modified) (1 diff)
• Tst/Manual/assPrimes.res.gz.uu (modified) (1 diff)
• Tst/Manual/assPrimes.stat (modified) (1 diff)
• Tst/Manual/modHenselStd.res.gz.uu (deleted)
• Tst/Manual/modHenselStd.stat (deleted)
• Tst/Manual/modHenselStd.tst (deleted)
• Tst/Manual/modS.res.gz.uu (deleted)
• Tst/Manual/modS.stat (deleted)
• Tst/Manual/modS.tst (deleted)
• Tst/Manual/modStd.res.gz.uu (modified) (1 diff)
• Tst/Manual/modStd.stat (modified) (1 diff)
• Tst/Manual/modStd.tst (modified) (1 diff)
• Tst/Manual/s.lst (modified) (2 diffs)
• Tst/New.lst (modified) (1 diff)
• Tst/New/AnnExt_R_bug.res.gz.uu (added)
• Tst/New/AnnExt_R_bug.stat (added)
• Tst/New/AnnExt_R_bug.tst (added)
• Tst/Rest.lst (modified) (1 diff)
• Tst/Short.lst (modified) (2 diffs)
• Tst/Short/bug_charseries.res.gz.uu (modified) (1 diff)
• Tst/Short/bug_charseries.stat (modified) (1 diff)
• Tst/Short/modstd.res.gz.uu (deleted)
• Tst/Short/modstd.stat (deleted)
• Tst/Short/modstd.tst (deleted)
• Tst/Short/modstd_s.res.gz.uu (added)
• Tst/Short/modstd_s.stat (added)
• Tst/Short/modstd_s.tst (added)
• Tst/Short/ok_s.lst (modified) (1 diff)
• Tst/Short/symodstd.stat (deleted)
• Tst/regress.lst (modified) (2 diffs)
• factory/cf_gcd.cc (modified) (1 diff)

Singular/LIB/assprimeszerodim.lib

@@ -294 +294 @@
 
    if(printlevel >= 10) { "========== Start modStd =========="; }
-   I = modStd(I,n1);
+   I = modStd(I);
    if(printlevel >= 10) { "=========== End modStd ==========="; }
    if(printlevel >= 9) { "modStd takes "+string(rtimer-RT)+" seconds."; }
@@ -325 +325 @@
                }
                TT = timer;
-               I = std(I);
+               I = modStd(I);
                if(printlevel >= 9)
                {
-                  "std(I) takes "+string(timer-TT)+" seconds.";
+                  "modStd(I) takes "+string(timer-TT)+" seconds.";
                }
                d = vdim(I);
@@ -343 +343 @@
             }
             TT = timer;
-            I = std(I);
+            I = modStd(I);
             if(printlevel >= 9)
             {
-               "std(I) takes "+string(timer-TT)+" seconds.";
+               "modStd(I) takes "+string(timer-TT)+" seconds.";
             }
             d = vdim(I);

Singular/LIB/modstd.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="version modstd.lib 4.0.0.0 Dec_2013 "; // $Id$
-category = "Commutative Algebra";
+version="version modstd.lib 4.0.0.0 May_2014 "; // $Id$
+category="Commutative Algebra";
 info="
-LIBRARY:  modstd.lib      Groebner basis of ideals
+LIBRARY:  modstd.lib      Groebner bases of ideals using modular methods
 
 AUTHORS:  A. Hashemi      Amir.Hashemi@lip6.fr
-@*        G. Pfister      pfister@mathematik.uni-kl.de
-@*        H. Schoenemann  hannes@mathematik.uni-kl.de
-@*        A. Steenpass    steenpass@mathematik.uni-kl.de
-@*        S. Steidel      steidel@mathematik.uni-kl.de
+          G. Pfister      pfister@mathematik.uni-kl.de
+          H. Schoenemann  hannes@mathematik.uni-kl.de
+          A. Steenpass    steenpass@mathematik.uni-kl.de
+          S. Steidel      steidel@mathematik.uni-kl.de
 
 OVERVIEW:
-
-  A library for computing the Groebner basis of an ideal in the polynomial
-  ring over the rational numbers using modular methods. The procedures are
-  inspired by the following paper:
-  Elizabeth A. Arnold: Modular algorithms for computing Groebner bases.
-  Journal of Symbolic Computation 35, 403-419 (2003).
+  A library for computing Groebner bases of ideals in the polynomial ring over
+  the rational numbers using modular methods.
+
+REFERENCES:
+  E. A. Arnold: Modular algorithms for computing Groebner bases.
+  J. Symb. Comp. 35, 403-419 (2003).
+
+  N. Idrees, G. Pfister, S. Steidel: Parallelization of Modular Algorithms.
+  J. Symb. Comp. 46, 672-684 (2011).
 
 PROCEDURES:
- modStd(I);        standard basis of I using modular methods (chinese remainder)
- modS(I,L);        liftings to Q of standard bases of I mod p for p in L
- modHenselStd(I);  standard basis of I using modular methods (hensel lifting)
+  modStd(I);    standard basis of I using modular methods
 ";
 
 LIB "poly.lib";
-LIB "ring.lib";
+LIB "modular.lib";
+
+proc modStd(ideal I, list #)
+"USAGE:   modStd(I[, exactness]); I ideal, exactness int
+RETURN:   a standard basis of I
+NOTE:     The procedure computes a standard basis of I (over the rational
+          numbers) by using modular methods.
+       @* An optional parameter 'exactness' can be provided.
+          If exactness = 1, the procedure computes a standard basis of I for
+          sure; if exactness = 0, it computes a standard basis of I
+          with high probability.
+SEE ALSO: modular
+EXAMPLE:  example modStd; shows an example"
+{
+    /* read optional parameter */
+    int exactness = 1;
+    if (size(#) > 0) {
+        /* For compatibility, we only test size(#) > 4. This can be changed to
+         * size(#) > 1 in the future. */
+        if (size(#) > 4 || typeof(#[1]) != "int") {
+            ERROR("wrong optional parameter");
+        }
+        exactness = #[1];
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* choose the right command */
+    string command = "groebner";
+    if (npars(basering) > 0) {
+        command = "Modstd::groebner_norm";
+    }
+
+    /* call modular() */
+    if (exactness) {
+        I = modular(command, list(I), primeTest_std,
+            deleteUnluckyPrimes_std, pTest_std, finalTest_std);
+    }
+    else {
+        I = modular(command, list(I), primeTest_std,
+            deleteUnluckyPrimes_std, pTest_std);
+    }
+
+    /* return the result */
+    attrib(I, "isSB", 1);
+    option(set, opt);
+    return(I);
+}
+example
+{
+    "EXAMPLE:";
+    echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    ideal J = modStd(I);
+    J;
+    I = homog(I, t);
+    J = modStd(I);
+    J;
+
+    ring R2 = 0, (x,y,z), ds;
+    ideal I = jacob(x5+y6+z7+xyz);
+    ideal J = modStd(I, 0);
+    J;
+
+    ring R3 = 0, x(1..4), lp;
+    ideal I = cyclic(4);
+    ideal J1 = modStd(I, 1);   // default
+    ideal J2 = modStd(I, 0);
+    size(reduce(J1, J2));
+    size(reduce(J2, J1));
+}
+
+/* compute a normalized GB via groebner() */
+static proc groebner_norm(ideal I)
+{
+    I = simplify(groebner(I), 1);
+    attrib(I, "isSB", 1);
+    return(I);
+}
+
+/* test if the prime p is suitable for the input, i.e. it does not divide
+ * the numerator or denominator of any of the coefficients */
+static proc primeTest_std(int p, alias list args)
+{
+    /* erase zero generators */
+    ideal I = simplify(args[1], 2);
+
+    /* clear denominators and count the terms */
+    ideal J;
+    ideal K;
+    int n = ncols(I);
+    intvec sizes;
+    number cnt;
+    int i;
+    for(i = n; i > 0; i--) {
+        J[i] = cleardenom(I[i]);
+        cnt = leadcoef(J[i])/leadcoef(I[i]);
+        K[i] = numerator(cnt)*var(1)+denominator(cnt);
+    }
+    sizes = size(J[1..n]);
+
+    /* change to characteristic p */
+    def br = basering;
+    list lbr = ringlist(br);
+    if (typeof(lbr[1]) == "int") {
+        lbr[1] = p;
+    }
+    else {
+        lbr[1][1] = p;
+    }
+    def rp = ring(lbr);
+    setring(rp);
+    ideal Jp = fetch(br, J);
+    ideal Kp = fetch(br, K);
+
+    /* test if any coefficient is missing */
+    if (intvec(size(Kp[1..n])) != 2:n) {
+        setring(br);
+        return(0);
+    }
+    if (intvec(size(Jp[1..n])) != sizes) {
+        setring(br);
+        return(0);
+    }
+    setring(br);
+    return(1);
+}
+
+/* find entries in modresults which come from unlucky primes.
+ * For this, sort the entries into categories depending on their leading
+ * ideal and return the indices in all but the biggest category. */
+static proc deleteUnluckyPrimes_std(alias list modresults)
+{
+    int size_modresults = size(modresults);
+
+    /* sort results into categories.
+     * each category is represented by three entries:
+     * - the corresponding leading ideal
+     * - the number of elements
+     * - the indices of the elements
+     */
+    list cat;
+    int size_cat;
+    ideal L;
+    int i;
+    int j;
+    for (i = 1; i <= size_modresults; i++) {
+        L = lead(modresults[i]);
+        attrib(L, "isSB", 1);
+        for (j = 1; j <= size_cat; j++) {
+            if (size(L) == size(cat[j][1])
+                && size(reduce(L, cat[j][1])) == 0
+                && size(reduce(cat[j][1], L)) == 0) {
+                cat[j][2] = cat[j][2]+1;
+                cat[j][3][cat[j][2]] = i;
+                break;
+            }
+        }
+        if (j > size_cat) {
+            size_cat++;
+            cat[size_cat] = list();
+            cat[size_cat][1] = L;
+            cat[size_cat][2] = 1;
+            cat[size_cat][3] = list(i);
+        }
+    }
+
+    /* find the biggest categories */
+    int cat_max = 1;
+    int max = cat[1][2];
+    for (i = 2; i <= size_cat; i++) {
+        if (cat[i][2] > max) {
+            cat_max = i;
+            max = cat[i][2];
+        }
+    }
+
+    /* return all other indices */
+    list unluckyIndices;
+    for (i = 1; i <= size_cat; i++) {
+        if (i != cat_max) {
+            unluckyIndices = unluckyIndices + cat[i][3];
+        }
+    }
+    return(unluckyIndices);
+}
+
+/* test if 'command' applied to 'args' in characteristic p is the same as
+   'result' mapped to characteristic p */
+static proc pTest_std(string command, list args, ideal result, int p)
+{
+    /* change to characteristic p */
+    def br = basering;
+    list lbr = ringlist(br);
+    if (typeof(lbr[1]) == "int") {
+        lbr[1] = p;
+    }
+    else {
+        lbr[1][1] = p;
+    }
+    def rp = ring(lbr);
+    setring(rp);
+    ideal Ip = fetch(br, args)[1];
+    ideal Gp = fetch(br, result);
+    attrib(Gp, "isSB", 1);
+
+    /* test if Ip is in Gp */
+    int i;
+    for (i = ncols(Ip); i > 0; i--) {
+        if (reduce(Ip[i], Gp, 1) != 0) {
+            setring(br);
+            return(0);
+        }
+    }
+
+    /* compute command(args) */
+    execute("Ip = "+command+"(Ip);");
+
+    /* test if Gp is in Ip */
+    for (i = ncols(Gp); i > 0; i--) {
+        if (reduce(Gp[i], Ip, 1) != 0) {
+            setring(br);
+            return(0);
+        }
+    }
+    setring(br);
+    return(1);
+}
+
+/* test if 'result' is a GB of the input ideal */
+static proc finalTest_std(string command, alias list args, ideal result)
+{
+    /* test if args[1] is in result */
+    attrib(result, "isSB", 1);
+    int i;
+    for (i = ncols(args[1]); i > 0; i--) {
+        if (reduce(args[1][i], result, 1) != 0) {
+            return(0);
+        }
+    }
+
+    /* test if result is a GB */
+    ideal G = std(result);
+    if (reduce_parallel(G, result)) {
+        return(0);
+    }
+    return(1);
+}
+
+/* return 1, if I_reduce is _not_ in G_reduce,
+ *        0, otherwise
+ * (same as size(reduce(I_reduce, G_reduce))).
+ * Uses parallelization. */
+static proc reduce_parallel(ideal I_reduce, ideal G_reduce)
+{
+    exportto(Modstd, I_reduce);
+    exportto(Modstd, G_reduce);
+    int size_I = ncols(I_reduce);
+    int chunks = Modular::par_range(size_I);
+    intvec range;
+    int i;
+    for (i = chunks; i > 0; i--) {
+        range = Modular::par_range(size_I, i);
+        task t(i) = "Modstd::reduce_task", list(range);
+    }
+    startTasks(t(1..chunks));
+    waitAllTasks(t(1..chunks));
+    int result = 0;
+    for (i = chunks; i > 0; i--) {
+        if (getResult(t(i))) {
+            result = 1;
+            break;
+        }
+    }
+    kill I_reduce;
+    kill G_reduce;
+    return(result);
+}
+
+/* compute a chunk of reductions for reduce_parallel */
+static proc reduce_task(intvec range)
+{
+    int result = 0;
+    int i;
+    for (i = range[1]; i <= range[2]; i++) {
+        if (reduce(I_reduce[i], G_reduce, 1) != 0) {
+            result = 1;
+            break;
+        }
+    }
+    return(result);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/*
+ * The following procedures are kept for backward compatibility with the old
+ * version of modstd.lib. As of now (May 2014), they are still needed in
+ * assprimeszerodim.lib, modnormal.lib, modwalk.lib, and symodstd.lib. They can
+ * be removed here as soon as they are not longer needed in these libraries.
+ */
+
 LIB "parallel.lib";
 
-////////////////////////////////////////////////////////////////////////////////
-
 static proc mod_init()
 {
    newstruct("idealPrimeTest", "ideal Ideal");
 }
-
-////////////////////////////////////////////////////////////////////////////////
 
 static proc redFork(ideal I, ideal J, int n)
@@ -43 +343 @@
    return(reduce(I,J,1));
 }
-
-////////////////////////////////////////////////////////////////////////////////
 
 proc isIncluded(ideal I, ideal J, list #)
@@ -149 +447 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-proc pTestSB(ideal I, ideal J, list L, int variant, list #)
-"USAGE:  pTestSB(I,J,L,variant,#); I,J ideals, L intvec of primes, variant int
-RETURN:  1 (resp. 0) if for a randomly chosen prime p that is not in L
-         J mod p is (resp. is not) a standard basis of I mod p
-EXAMPLE: example pTestSB; shows an example
-"
-{
-   int i,j,k,p;
-   def R = basering;
-   list r = ringlist(R);
-
-   while(!j)
-   {
-      j = 1;
-      p = prime(random(1000000000,2134567879));
-      for(i = 1; i <= size(L); i++)
-      {
-         if(p == L[i]) { j = 0; break; }
-      }
-      if(j)
-      {
-         for(i = 1; i <= ncols(I); i++)
-         {
-            for(k = 2; k <= size(I[i]); k++)
-            {
-               if((denominator(leadcoef(I[i][k])) mod p) == 0) { j = 0; break; }
-            }
-            if(!j){ break; }
-         }
-      }
-      if(j)
-      {
-         if(!primeTest(I,p)) { j = 0; }
-      }
-   }
-   r[1] = p;
-   def @R = ring(r);
-   setring @R;
-   ideal I = imap(R,I);
-   ideal J = imap(R,J);
-   attrib(J,"isSB",1);
-
-   int t = timer;
-   j = 1;
-   if(isIncluded(I,J) == 0) { j = 0; }
-
-   if(printlevel >= 11)
-   {
-      "isIncluded(I,J) takes "+string(timer - t)+" seconds";
-      "j = "+string(j);
-   }
-
-   t = timer;
-   if(j)
-   {
-      if(size(#) > 0)
-      {
-         ideal K = modpStd(I,p,variant,#[1])[1];
-      }
-      else
-      {
-         ideal K = groebner(I);
-      }
-      t = timer;
-      if(isIncluded(J,K) == 0) { j = 0; }
-
-      if(printlevel >= 11)
-      {
-         "isIncluded(J,K) takes "+string(timer - t)+" seconds";
-         "j = "+string(j);
-      }
-   }
-   setring R;
-   return(j);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   intvec L = 2,3,5;
-   ring r = 0,(x,y,z),dp;
-   ideal I = x+1,x+y+1;
-   ideal J = x+1,y;
-   pTestSB(I,I,L,2);
-   pTestSB(I,J,L,2);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 proc deleteUnluckyPrimes(list T, list L, int ho, list #)
 "USAGE:  deleteUnluckyPrimes(T,L,ho,#); T/L list of polys/primes, ho integer
@@ -347 +556 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
 proc primeTest(def II, bigint p)
 {
@@ -379 +586 @@
    return(1);
 }
-
-////////////////////////////////////////////////////////////////////////////////
 
 proc primeList(ideal I, int n, list #)
@@ -498 +703 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-static proc liftstd1(ideal I)
-{
-   def R = basering;
-   list rl = ringlist(R);
-   list ordl = rl[3];
-
-   int i;
-   for(i = 1; i <= size(ordl); i++)
-   {
-      if((ordl[i][1] == "C") || (ordl[i][1] == "c"))
-      {
-         ordl = delete(ordl, i);
-         break;
-      }
-   }
-
-   ordl = insert(ordl, list("c", 0));
-   rl[3] = ordl;
-   def newR = ring(rl);
-   setring newR;
-   ideal I = imap(R,I);
-
-   intvec opt = option(get);
-   option(none);
-   option(prompt);
-
-   module M;
-   for(i = 1; i <= size(I); i++)
-   {
-      M = M + module(I[i]*gen(1) + gen(i+1));
-      M = M + module(gen(i+1));
-   }
-
-   module sM = std(M);
-
-   ideal sI;
-   if(attrib(R,"global"))
-   {
-      for(i = size(I)+1; i <= size(sM); i++)
-      {
-         sI[size(sI)+1] = sM[i][1];
-      }
-      matrix T = submat(sM,2..nrows(sM),size(I)+1..ncols(sM));
-   }
-   else
-   {
-      //"==========================================================";
-      //"WARNING: Algorithm is not applicable if ordering is mixed.";
-      //"==========================================================";
-      for(i = 1; i <= size(sM)-size(I); i++)
-      {
-         sI[size(sI)+1] = sM[i][1];
-      }
-      matrix T = submat(sM,2..nrows(sM),1..ncols(sM)-size(I));
-   }
-
-   setring R;
-   option(set, opt);
-   return(imap(newR,sI),imap(newR,T));
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   ring R = 0,(x,y,z),dp;
-   poly f = x3+y7+z2+xyz;
-   ideal i = jacob(f);
-   matrix T;
-   ideal sm = liftstd(i,T);
-   sm;
-   print(T);
-   matrix(sm) - matrix(i)*T;
-
-
-   ring S = 32003, x(1..5), lp;
-   ideal I = cyclic(5);
-   ideal sI;
-   matrix T;
-   sI,T = liftstd1(I);
-   matrix(sI) - matrix(I)*T;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-proc modpStd(ideal I, int p, int variant, list #)
-"USAGE:  modpStd(I,p,variant,#); I ideal, p integer, variant integer
-ASSUME:  If size(#) > 0, then #[1] is an intvec describing the Hilbert series.
-RETURN:  ideal - a standard basis of I mod p, integer - p
-NOTE:    The procedure computes a standard basis of the ideal I modulo p and
-         fetches the result to the basering. If size(#) > 0 the Hilbert driven
-         standard basis computation std(.,#[1]) is used instead of groebner.
-         The standard basis computation modulo p does also vary depending on the
-         integer variant, namely
-@*       - variant = 1: std(.,#[1]) resp. groebner,
-@*       - variant = 2: groebner,
-@*       - variant = 3: homog. - std(.,#[1]) resp. groebner - dehomog.,
-@*       - variant = 4: fglm.
-EXAMPLE: example modpStd; shows an example
-"
-{
-   def R0 = basering;
-   list rl = ringlist(R0);
-   rl[1] = p;
-   def @r = ring(rl);
-   setring @r;
-   ideal i = fetch(R0,I);
-
-   option(redSB);
-
-   if(variant == 1)
-   {
-      if(size(#) > 0)
-      {
-         i = std(i, #[1]);
-      }
-      else
-      {
-         i = groebner(i);
-      }
-   }
-
-   if(variant == 2)
-   {
-      i = groebner(i);
-   }
-
-   if(variant == 3)
-   {
-      list rl = ringlist(@r);
-      int nvar@r = nvars(@r);
-
-      int k;
-      intvec w;
-      for(k = 1; k <= nvar@r; k++)
-      {
-         w[k] = deg(var(k));
-      }
-      w[nvar@r + 1] = 1;
-
-      rl[2][nvar@r + 1] = "homvar";
-      rl[3][2][2] = w;
-
-      def HomR = ring(rl);
-      setring HomR;
-      ideal i = imap(@r, i);
-      i = homog(i, homvar);
-
-      if(size(#) > 0)
-      {
-         if(w == 1)
-         {
-            i = std(i, #[1]);
-         }
-         else
-         {
-            i = std(i, #[1], w);
-         }
-      }
-      else
-      {
-         i = groebner(i);
-      }
-
-      i = subst(i, homvar, 1);
-      i = simplify(i, 34);
-
-      setring @r;
-      i = imap(HomR, i);
-      i = interred(i);
-      kill HomR;
-   }
-
-   if(variant == 4)
-   {
-      def R1 = changeord(list(list("dp",1:nvars(basering))));
-      setring R1;
-      ideal i = fetch(@r,i);
-      i = std(i);
-      setring @r;
-      i = fglm(R1,i);
-   }
-
-   setring R0;
-   return(list(fetch(@r,i),p));
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   ring r = 0, x(1..4), dp;
-   ideal I = cyclic(4);
-   int p = 181;
-   list P = modpStd(I,p,2);
-   P;
-
-   ring r2 = 0, x(1..5), lp;
-   ideal I = cyclic(5);
-   int q = 32003;
-   list Q = modpStd(I,q,4);
-   Q;
-}
-
-static proc algeModStd(ideal i,list #)
-{
-//reduces modStd over algebraic extensions to the one over a polynomial ring
-   list L=#;
-   def R=basering;
-   int n=nvars(R);
-   list rl=ringlist(R);
-   poly p=minpoly;
-   rl[2][n+1]=rl[1][2][1];
-   rl[1]=rl[1][1];
-   rl[3][size(rl[3])+1]=rl[3][size(rl[3])];
-   rl[3][size(rl[3])-1]=list("dp",1);
-   def S=ring(rl);
-   setring S;
-   poly p=imap(R,p);
-   ideal i=imap(R,i);
-   i=i,p;
-   ideal j=modStd(i,L);
-   if(j[1]==p)
-   {
-      j[1]=0;
-   }
-   j=simplify(j,2);
-   setring R;
-   ideal j=imap(S,j);
-   return(j);
-}
-////////////////////////////// main procedures /////////////////////////////////
-
-proc modStd(ideal I, list #)
-"USAGE:  modStd(I); I ideal
-ASSUME:  If size(#) > 0, then # contains either 1, 2 or 4 integers such that
-@*       - #[1] is the number of available processors for the computation,
-@*       - #[2] is an optional parameter for the exactness of the computation,
-                if #[2] = 1, the procedure computes a standard basis for sure,
-@*       - #[3] is the number of primes until the first lifting,
-@*       - #[4] is the constant number of primes between two liftings until
-           the computation stops.
-RETURN:  a standard basis of I if no warning appears;
-NOTE:    The procedure computes a standard basis of I (over the rational
-         numbers) by using modular methods.
-         By default the procedure computes a standard basis of I for sure, but
-         if the optional parameter #[2] = 0, it computes a standard basis of I
-         with high probability.
-         The procedure distinguishes between different variants for the standard
-         basis computation in positive characteristic depending on the ordering
-         of the basering, the parameter #[2] and if the ideal I is homogeneous.
-@*       - variant = 1, if I is homogeneous,
-@*       - variant = 2, if I is not homogeneous, 1-block-ordering,
-@*       - variant = 3, if I is not homogeneous, complicated ordering (lp or
-                        > 1 block),
-@*       - variant = 4, if I is not homogeneous, ordering lp, dim(I) = 0.
-EXAMPLE: example modStd; shows an example
-"
-{
-   int TT = timer;
-   int RT = rtimer;
-
-   def R0 = basering;
-   list rl = ringlist(R0);
-
-   int algebraic;
-   if(size(#)>0)
-   {
-      if(#[1]<=0)
-      {
-         algebraic=1;
-         #[1]=-#[1];
-         if(#[1]==0){list LK;#=LK;}
-      }
-   }
-
-   if((npars(R0) > 0) || (rl[1][1] > 0))
-   {
-      if(npars(R0)==1)
-      {
-         if(minpoly!=0)
-         {
-            list LM=#;
-            if(size(LM)==0){LM[1]=0;}
-            LM[1]=-LM[1];
-            return(algeModStd(I,LM));
-         }
-      }
-
-      ERROR("Characteristic of basering should be zero, basering should
-             have no parameters.");
-   }
-
-   int index = 1;
-   int i,k,c;
-   int j = 1;
-   int pTest, sizeTest;
-   int en = 2134567879;
-   int an = 1000000000;
-   bigint N;
-
-//--------------------  Initialize optional parameters  ------------------------
-   if(size(#) > 0)
-   {
-      if(size(#) == 1)
-      {
-         int n1 = #[1];
-         int exactness = 1;
-         if(n1 >= 10)
-         {
-            int n2 = n1 + 1;
-            int n3 = n1;
-         }
-         else
-         {
-            int n2 = 10;
-            int n3 = 10;
-         }
-      }
-      if(size(#) == 2)
-      {
-         int n1 = #[1];
-         int exactness = #[2];
-         if(n1 >= 10)
-         {
-            int n2 = n1 + 1;
-            int n3 = n1;
-         }
-         else
-         {
-            int n2 = 10;
-            int n3 = 10;
-         }
-      }
-      if(size(#) == 4)
-      {
-         int n1 = #[1];
-         int exactness = #[2];
-         if(n1 >= #[3])
-         {
-            int n2 = n1 + 1;
-         }
-         else
-         {
-            int n2 = #[3];
-         }
-         if(n1 >= #[4])
-         {
-            int n3 = n1;
-         }
-         else
-         {
-            int n3 = #[4];
-         }
-      }
-   }
-   else
-   {
-      int n1 = 1;
-      int exactness = 1;
-      int n2 = 10;
-      int n3 = 10;
-   }
-
-   if(printlevel >= 10)
-   {
-      "n1 = "+string(n1)+", n2 = "+string(n2)+", n3 = "+string(n3)
-       +", exactness = "+string(exactness);
-   }
-
-//-------------------------  Save current options  -----------------------------
-   intvec opt = option(get);
-
-   option(redSB);
-
-//--------------------  Initialize the list of primes  -------------------------
-   int tt = timer;
-   int rt = rtimer;
-   intvec L = primeList(I,n2,n1);
-   if(printlevel >= 10)
-   {
-      "CPU-time for primeList: "+string(timer-tt)+" seconds.";
-      "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
-   }
-   L[5] = prime(random(an,en));
-
-//---------------------  Decide which variant to take  -------------------------
-   int variant;
-   int h = homog(I);
-
-   tt = timer;
-   rt = rtimer;
-
-   if(!hasMixedOrdering())
-   {
-      if(h)
-      {
-         variant = 1;
-         if(printlevel >= 10) { "variant = 1"; }
-
-         rl[1] = L[5];
-         def @r = ring(rl);
-         setring @r;
-         def @s = changeord(list(list("dp",1:nvars(basering))));
-         setring @s;
-         ideal I = std(fetch(R0,I));
-         intvec hi = hilb(I,1);
-         setring R0;
-         kill @r,@s;
-      }
-      else
-      {
-         string ordstr_R0 = ordstr(R0);
-         int neg = 1 - attrib(R0,"global");
-
-         if((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg)
-         {
-            variant = 2;
-            if(printlevel >= 10) { "variant = 2"; }
-         }
-         else
-         {
-            string order;
-            if(system("nblocks") <= 2)
-            {
-               if(find(ordstr_R0, "M") + find(ordstr_R0, "lp")
-                                       + find(ordstr_R0, "rp") <= 0)
-               {
-                  order = "simple";
-               }
-            }
-
-            if((order == "simple") || (size(rl) > 4))
-            {
-               variant = 2;
-               if(printlevel >= 10) { "variant = 2"; }
-            }
-            else
-            {
-               rl[1] = L[5];
-               def @r = ring(rl);
-               setring @r;
-
-               def @s = changeord(list(list("dp",1:nvars(basering))));
-               setring @s;
-               ideal I = std(fetch(R0,I));
-               if(dim(I) == 0)
-               {
-                  variant = 4;
-                  if(printlevel >= 10) { "variant = 4"; }
-               }
-               else
-               {
-                  variant = 3;
-                  if(printlevel >= 10) { "variant = 3"; }
-
-                  int nvar@r = nvars(@r);
-                  intvec w;
-                  for(i = 1; i <= nvar@r; i++)
-                  {
-                     w[i] = deg(var(i));
-                  }
-                  w[nvar@r + 1] = 1;
-
-                  list hiRi = hilbRing(fetch(R0,I),w);
-                  intvec W = hiRi[2];
-                  @s = hiRi[1];
-                  setring @s;
-
-                  Id(1) = std(Id(1));
-                  intvec hi = hilb(Id(1), 1, W);
-               }
-
-               setring R0;
-               kill @r,@s;
-            }
-         }
-      }
-   }
-   else
-   {
-      if(exactness == 1) { return(groebner(I)); }
-      if(h)
-      {
-         variant = 1;
-         if(printlevel >= 10) { "variant = 1"; }
-         rl[1] = L[5];
-         def @r = ring(rl);
-         setring @r;
-         def @s = changeord(list(list("dp",1:nvars(basering))));
-         setring @s;
-         ideal I = std(fetch(R0,I));
-         intvec hi = hilb(I,1);
-         setring R0;
-         kill @r,@s;
-      }
-      else
-      {
-         string ordstr_R0 = ordstr(R0);
-         int neg = 1 - attrib(R0,"global");
-
-         if((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg)
-         {
-            variant = 2;
-            if(printlevel >= 10) { "variant = 2"; }
-         }
-         else
-         {
-            string order;
-            if(system("nblocks") <= 2)
-            {
-               if(find(ordstr_R0, "M") + find(ordstr_R0, "lp")
-                                       + find(ordstr_R0, "rp") <= 0)
-               {
-                  order = "simple";
-               }
-            }
-
-            if((order == "simple") || (size(rl) > 4))
-            {
-               variant = 2;
-               if(printlevel >= 10) { "variant = 2"; }
-            }
-            else
-            {
-               variant = 3;
-               if(printlevel >= 10) { "variant = 3"; }
-
-               rl[1] = L[5];
-               def @r = ring(rl);
-               setring @r;
-               int nvar@r = nvars(@r);
-               intvec w;
-               for(i = 1; i <= nvar@r; i++)
-               {
-                  w[i] = deg(var(i));
-               }
-               w[nvar@r + 1] = 1;
-
-               list hiRi = hilbRing(fetch(R0,I),w);
-               intvec W = hiRi[2];
-               def @s = hiRi[1];
-               setring @s;
-
-               Id(1) = std(Id(1));
-               intvec hi = hilb(Id(1), 1, W);
-
-               setring R0;
-               kill @r,@s;
-            }
-         }
-      }
-   }
-   if(algebraic){variant=2;}
-
-   list P,T1,T2,T3,LL;
-
-   ideal J,K,H;
-
-//-----  If there is more than one processor available, we parallelize the  ----
-//-----  main standard basis computations in positive characteristic        ----
-
-   if(n1 > 1)
-   {
-      ideal I_for_fork = I;
-      export(I_for_fork);           // I available for each link
-
-//-----  Create n1 links l(1),...,l(n1), open all of them and compute  ---------
-//-----  standard basis for the primes L[2],...,L[n1 + 1].             ---------
-
-      for(i = 1; i <= n1; i++)
-      {
-         //link l(i) = "MPtcp:fork";
-         link l(i) = "ssi:fork";
-         open(l(i));
-         if((variant == 1) || (variant == 3))
-         {
-            write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
-                                                  eval(variant), eval(hi))));
-         }
-         if((variant == 2) || (variant == 4))
-         {
-            write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
-                                                  eval(variant))));
-         }
-      }
-
-      int t = timer;
-      if((variant == 1) || (variant == 3))
-      {
-         P = modpStd(I_for_fork, L[1], variant, hi);
-      }
-      if((variant == 2) || (variant == 4))
-      {
-         P = modpStd(I_for_fork, L[1], variant);
-      }
-      t = timer - t;
-      if(t > 60) { t = 60; }
-      int i_sleep = system("sh", "sleep "+string(t));
-      T1[1] = P[1];
-      T2[1] = bigint(P[2]);
-      index++;
-
-      j = j + n1 + 1;
-   }
-
-//--------------  Main standard basis computations in positive  ----------------
-//----------------------  characteristic start here  ---------------------------
-
-   list arguments_farey, results_farey;
-
-   while(1)
-   {
-      tt = timer; rt = rtimer;
-
-      if(printlevel >= 10) { "size(L) = "+string(size(L)); }
-
-      if(n1 > 1)
-      {
-         while(j <= size(L) + 1)
-         {
-            for(i = 1; i <= n1; i++)
-            {
-               //--- ask if link l(i) is ready otherwise sleep for t seconds ---
-               if(status(l(i), "read", "ready"))
-               {
-                  //--- read the result from l(i) ---
-                  P = read(l(i));
-                  T1[index] = P[1];
-                  T2[index] = bigint(P[2]);
-                  index++;
-
-                  if(j <= size(L))
-                  {
-                     if((variant == 1) || (variant == 3))
-                     {
-                        write(l(i), quote(modpStd(I_for_fork, eval(L[j]),
-                                                  eval(variant), eval(hi))));
-                        j++;
-                     }
-                     if((variant == 2) || (variant == 4))
-                     {
-                        write(l(i), quote(modpStd(I_for_fork,
-                                                  eval(L[j]), eval(variant))));
-                        j++;
-                     }
-                  }
-                  else
-                  {
-                     k++;
-                     close(l(i));
-                  }
-               }
-            }
-            //--- k describes the number of closed links ---
-            if(k == n1)
-            {
-               j++;
-            }
-            i_sleep = system("sh", "sleep "+string(t));
-         }
-      }
-      else
-      {
-         while(j <= size(L))
-         {
-            if((variant == 1) || (variant == 3))
-            {
-               P = modpStd(I, L[j], variant, hi);
-            }
-            if((variant == 2) || (variant == 4))
-            {
-               P = modpStd(I, L[j], variant);
-            }
-
-            T1[index] = P[1];
-            T2[index] = bigint(P[2]);
-            index++;
-            j++;
-         }
-      }
-
-      if(printlevel >= 10)
-      {
-         "CPU-time for computing list is "+string(timer - tt)+" seconds.";
-         "Real-time for computing list is "+string(rtimer - rt)+" seconds.";
-      }
-
-//------------------------  Delete unlucky primes  -----------------------------
-//-------------  unlucky if and only if the leading ideal is wrong  ------------
-
-      LL = deleteUnluckyPrimes(T1,T2,h);
-      T1 = LL[1];
-      T2 = LL[2];
-
-//-------------------  Now all leading ideals are the same  --------------------
-//-------------------  Lift results to basering via farey  ---------------------
-
-      tt = timer; rt = rtimer;
-      N = T2[1];
-      for(i = 2; i <= size(T2); i++) { N = N*T2[i]; }
-      H = chinrem(T1,T2);
-      if(n1 == 1)
-      {
-         J = farey(H,N);
-      }
-      else
-      {
-         for(i = ncols(H); i > 0; i--)
-         {
-            arguments_farey[i] = list(ideal(H[i]), N);
-         }
-         results_farey = parallelWaitAll("farey", arguments_farey, 0, n1);
-         for(i = ncols(H); i > 0; i--)
-         {
-            J[i] = results_farey[i][1];
-         }
-      }
-      if(printlevel >= 10)
-      {
-         "CPU-time for lifting-process is "+string(timer - tt)+" seconds.";
-         "Real-time for lifting-process is "+string(rtimer - rt)+" seconds.";
-      }
-
-//----------------  Test if we already have a standard basis of I --------------
-
-      tt = timer; rt = rtimer;
-      if((variant == 1) || (variant == 3))
-      {
-         pTest = pTestSB(I,J,L,variant,hi);
-      }
-      if((variant == 2) || (variant == 4))
-      {
-         pTest = pTestSB(I,J,L,variant);
-      }
-
-      if(printlevel >= 10)
-      {
-         "CPU-time for pTest is "+string(timer - tt)+" seconds.";
-         "Real-time for pTest is "+string(rtimer - rt)+" seconds.";
-      }
-
-      if(pTest)
-      {
-         if(printlevel >= 10)
-         {
-            "CPU-time for computation without final tests is "
-            +string(timer - TT)+" seconds.";
-            "Real-time for computation without final tests is "
-            +string(rtimer - RT)+" seconds.";
-         }
-
-         attrib(J,"isSB",1);
-
-         if(exactness == 0)
-         {
-            option(set, opt);
-            if(n1 > 1) { kill I_for_fork; }
-            return(J);
-         }
-
-         if(exactness == 1)
-         {
-            tt = timer; rt = rtimer;
-            sizeTest = 1 - isIncluded(I,J,n1);
-
-            if(printlevel >= 10)
-            {
-               "CPU-time for checking if I subset <G> is "
-               +string(timer - tt)+" seconds.";
-               "Real-time for checking if I subset <G> is "
-               +string(rtimer - rt)+" seconds.";
-            }
-
-            if(sizeTest == 0)
-            {
-               tt = timer; rt = rtimer;
-               K = std(J);
-
-               if(printlevel >= 10)
-               {
-                  "CPU-time for last std-computation is "
-                  +string(timer - tt)+" seconds.";
-                  "Real-time for last std-computation is "
-                  +string(rtimer - rt)+" seconds.";
-               }
-
-               if(size(reduce(K,J)) == 0)
-               {
-                  option(set, opt);
-                  if(n1 > 1) { kill I_for_fork; }
-                  return(J);
-               }
-            }
-         }
-      }
-
-//--------------  We do not already have a standard basis of I  ----------------
-//-----------  Therefore do the main computation for more primes  --------------
-
-      T1 = H;
-      T2 = N;
-      index = 2;
-
-      j = size(L) + 1;
-      tt = timer; rt = rtimer;
-      L = primeList(I,n3,L,n1);
-      if(printlevel >= 10)
-      {
-         "CPU-time for primeList: "+string(timer-tt)+" seconds.";
-         "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
-      }
-
-      if(n1 > 1)
-      {
-         for(i = 1; i <= n1; i++)
-         {
-            open(l(i));
-            if((variant == 1) || (variant == 3))
-            {
-               write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
-                                                     eval(variant), eval(hi))));
-            }
-            if((variant == 2) || (variant == 4))
-            {
-               write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
-                                                     eval(variant))));
-            }
-         }
-         j = j + n1;
-         k = 0;
-      }
-   }
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   ring R1 = 0,(x,y,z,t),dp;
-   ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
-   ideal J = modStd(I);
-   J;
-   I = homog(I,t);
-   J = modStd(I);
-   J;
-
-   ring R2 = 0,(x,y,z),ds;
-   ideal I = jacob(x5+y6+z7+xyz);
-   ideal J1 = modStd(I,1,0);
-   J1;
-
-   ring R3 = 0,x(1..4),lp;
-   ideal I = cyclic(4);
-   ideal J1 = modStd(I,1);
-   ideal J2 = modStd(I,1,0);
-   size(reduce(J1,J2));
-   size(reduce(J2,J1));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-proc modS(ideal I, list L, list #)
-"USAGE:  modS(I,L); I ideal, L intvec of primes
-         if size(#)>0 std is used instead of groebner
-RETURN:  an ideal which is with high probability a standard basis
-NOTE:    This procedure is designed for fast experiments.
-         It is not tested whether the result is a standard basis.
-         It is not tested whether the result generates I.
-EXAMPLE: example modS; shows an example
-"
-{
-   int j;
-   bigint N = 1;
-   def R0 = basering;
-   ideal J;
-   list T;
-   list rl = ringlist(R0);
-   if((npars(R0)>0) || (rl[1]>0))
-   {
-      ERROR("Characteristic of basering should be zero.");
-   }
-   for(j = 1; j <= size(L); j++)
-   {
-      N = N*L[j];
-      rl[1] = L[j];
-      def @r = ring(rl);
-      setring @r;
-      ideal I = fetch(R0,I);
-      if(size(#) > 0)
-      {
-         I = std(I);
-      }
-      else
-      {
-         I = groebner(I);
-      }
-      setring R0;
-      T[j] = fetch(@r,I);
-      kill @r;
-   }
-   L = deleteUnluckyPrimes(T,L,homog(I));
-   // unlucky if and only if the leading ideal is wrong
-   J = farey(chinrem(L[1],L[2]),N);
-   attrib(J,"isSB",1);
-   return(J);
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   list L = 3,5,11,13,181,32003;
-   ring r = 0,(x,y,z,t),dp;
-   ideal I = 3x3+x2+1,11y5+y3+2,5z4+z2+4;
-   I = homog(I,t);
-   ideal J = modS(I,L);
-   J;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-proc modHenselStd(ideal I, list #)
-"USAGE:  modHenselStd(I);
-RETURN:  a standard basis of I;
-NOTE:    The procedure computes a standard basis of I (over the rational
-         numbers) by using  modular computations and Hensellifting.
-         For further experiments see procedure modS.
-EXAMPLE: example modHenselStd; shows an example
-"
-{
-   int i,j;
-
-   bigint p = 2134567879;
-   if(size(#)!=0) { p=#[1]; }
-   while(!primeTest(I,p))
-   {
-      p = prime(random(2000000000,2134567879));
-   }
-
-   def R = basering;
-   module F,PrevG,PrevZ,Z2;
-   ideal testG,testG1,G1,G2,G3,Gp;
-   list L = p;
-   list rl = ringlist(R);
-   rl[1] = int(p);
-
-   def S = ring(rl);
-   setring S;
-   intvec opt = option(get);
-   option(redSB);
-   module Z,M,Z2;
-   ideal I = imap(R,I);
-   ideal Gp,G1,G2,G3;
-   Gp,Z = liftstd1(I);
-   attrib(Gp,"isSB",1);
-   module ZZ = syz(I);
-   attrib(ZZ,"isSB",1);
-   Z = reduce(Z,ZZ);
-
-   setring R;
-   Gp = imap(S,Gp);
-   PrevZ = imap(S,Z);
-   PrevG = module(Gp);
-   F = module(I);
-   testG = farey(Gp,p);
-   attrib(testG,"isSB",1);
-   while(1)
-   {
-      i++;
-      G1 = ideal(1/(p^i) * sum_id(F*PrevZ,(-1)*PrevG));
-      setring S;
-      G1 = imap(R,G1);
-      G2 = reduce(G1,Gp);
-      G3 = sum_id(G1,(-1)*G2);
-      M = lift(Gp,G3);
-      Z2 = (-1)*Z*M;
-
-      setring R;
-      G2 = imap(S,G2);
-      Z2 = imap(S,Z2);
-      PrevG = sum_id(PrevG, module(p^i*G2));
-      PrevZ = sum_id(PrevZ, multiply(poly(p^i),Z2));
-      testG1 = farey(ideal(PrevG),p^(i+1));
-      attrib(testG1,"isSB",1);
-      if(size(reduce(testG1,testG)) == 0)
-      {
-         if(size(reduce(I,testG1)) == 0)       // I is in testG1
-         {
-            if(pTestSB(I,testG1,L,2))
-            {
-               G3 = std(testG1);               // testG1 is SB
-               if(size(reduce(G3,testG1)) == 0)
-               {
-                  option(set, opt);
-                  return(G3);
-               }
-            }
-         }
-      }
-      testG = testG1;
-      attrib(testG,"isSB",1);
-   }
-}
-example
-{ "EXAMPLE:"; echo = 2;
-   ring r = 0,(x,y,z),dp;
-   ideal I = 3x3+x2+1,11y5+y3+2,5z4+z2+4;
-   ideal J = modHenselStd(I);
-   J;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-static proc sum_id(list #)
-{
-   if(typeof(#[1])=="ideal")
-   {
-      ideal M;
-   }
-   else
-   {
-      module M;
-   }
-
-   int i;
-   for(i = 1; i <= ncols(#[1]); i++) { M[i] = #[1][i] + #[2][i]; }
-   return(M);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-static proc multiply(poly p, list #)
-{
-   if(typeof(#[1])=="ideal")
-   {
-      ideal M;
-   }
-   else
-   {
-      module M;
-   }
-
-   int i;
-   for(i = 1; i <= ncols(#[1]); i++) { M[i] = p * #[1][i]; }
-   return(M);
-}
-
-
 ////////////////////////////// further examples ////////////////////////////////
 

Singular/LIB/modular.lib

@@ -1 +1 @@
 ////////////////////////////////////////////////////////////////////
-version="version modular.lib 3-1-7-0 Dec_2013 ";
+version="version modular.lib 4.0.0.0 May_2014 "; // $Id$
 category="General purpose";
 info="
@@ -126 +126 @@
         else {
             ncores_available = system("semaphore", "get_value", sem_cores)+1;
-            nNewPrimes = nAllPrimes div ncores_available;
             if (nAllPrimes < ncores_available) {
                 nNewPrimes = nAllPrimes;
@@ -155 +154 @@
         for (i = size(indices); i > 0; i--) {
             modresults = delete(modresults, indices[i]);
+            primes = delete(primes, indices[i]);
         }
 
@@ -165 +165 @@
                 list(N)+primes);
         }
+        modresults = list();
         for (i = size(primes); i > 0; i--) {
             N = N*primes[i];

Singular/LIB/primdec.lib

@@ -3995 +3995 @@
   if(n<nvars(basering))
   {
-     matrix f=transpose(re[n+1]);      //Hom(_,R)
-     module k=nres(f,2)[2];            //the kernel
-     matrix g=transpose(re[n]);        //the image of Hom(_,R)
-
-     ideal ann=quotient1(g,k);           //the anihilator
-  }
-  else
-  {
-     ideal ann=Ann(transpose(re[n]));
-  }
+    if(size(re[n+1])>0)
+    {
+        matrix f=transpose(re[n+1]);      //Hom(_,R)
+        module k=nres(f,2)[2];            //the kernel
+        matrix g=transpose(re[n]);        //the image of Hom(_,R)
+
+        ideal ann=quotient1(g,k);         //the anihilator
+        return(ann);
+    }
+  }
+  // remaining case: re[n+1] is trivial
+  // either n is at least number of variables or
+  // resolution happens to be shorter
+  ideal ann=Ann(transpose(re[n]));
   return(ann);
 }
@@ -4148 +4152 @@
   matrix m=char_series(PS);  // We compute an irreducible
                              // characteristic series
+  if ((nrows(m)==1)
+  && (ncols(m)==1)
+  && (m[1,1]==1)) // in case of an empty series: min_ass_prim_charsets1
+  {
+    return min_ass_prim_charsets1(PS);
+  }
   int i,j,k;
   list PSI;
@@ -4247 +4257 @@
   matrix m=char_series(PS);  // We compute an irreducible
                              // characteristic series
+                             // this series may be empty (1x1: 1)
   int i,j,k;
+  while ((nrows(m)==1)
+  && (ncols(m)==1)
+  && (m[1,1]==1)) // in case of an empty series: permute the variables
+  {
+    n=string(var(nvars(oldring)));
+    for(i=1;i<nvars(oldring);i++) { n=n+","+string(var(i)); }
+    kill r;
+    execute("ring r=("+charstr(oldring)+"),("+n+"),dp;");
+    ideal PS=imap(oldring,PS);
+    matrix m=char_series(PS);
+  }
   ideal I;
   list PSI;

Tst/Long/ok_l.lst

@@ -35 +35 @@
 minor_l
 modnormal
+modstd_l
 modulo_l
 monodromy_l

Tst/Manual.lst

@@ -1014 +1014 @@
 Manual/Maxord.tst
 Manual/minpoly.tst
-Manual/modHenselStd.tst
 Manual/module_containment.tst
 Manual/modulo_BR_PLURAL_BR.tst
@@ -1145 +1144 @@
 Manual/minAssGTZ.tst
 Manual/mindist.tst
-Manual/modS.tst
 Manual/multiplylist.tst
 Manual/nonMonomials.tst

Tst/Manual/all.lst

@@ -921 +921 @@
 mod2str.tst
 modDec.tst
-modHenselStd.tst
-modS.tst
 modStd.tst
 mod_versal.tst

Tst/Manual/assPrimes.res.gz.uu

@@ -1 @@
-begin 640 assPrimes.res.gz
-M'XL(".\H<DX``V%S<U!R:6UE<RYR97,`[=U=B]S(%0;@>_V*9LF%38ULU:GO
-M-3,786\,80GQWBW&Z',9V'46SX1`?GW>4U7='G*;9A?<+QC/C%2JSZ-Z4+=4
-M^O#3#^]_/)U.]N'TM_=_/7WW_/3\YM?'Y;MW)_SVZ?'SX_.KU^\&_7EZ>#C-
-M3T]___+XV_[TYO/^[S=/S_/S\*%G(#T#)/F])OG/_N6?V^-O+;=+,O=P^O+X
-M^9?3/T[WI^GNU7RWW*UWV]U^=[R^VW[_FLX_G!ZW??[U]/YT?]D8WISD6(SL
-MJ]G$S/AW=]D7==^*?9N193;+USU)]VQF%R/K;%:SR-=]6??M1K;9X+CUQ5'E
-MS>G`$?ML=/=BUJ]'V4F/FLV!W:C-MEZJ;>V+/GKU'CWWL_WX_8#L/N&7^W4S
-MRV[FP]BW<K2M@JTH9D'I\VY0XMZVNX_WRVIF5+NFWMI6CZU(/:^U-=MAUK8]
-M?+R?%[/M9JVIE[8U8JMH3\F*-BR'F=OV]/%^VW7'H7L.LQPRAK<N]BIE[!9D
-MM<LX8X_65?\OO68%=4!),W*848,==4:2O?Z_:?$V]UK9"170I*C5CL*VEA1;
-M\/_:DO:J6O3.YD:WH-`X[\=XX`_\L&]];[H5+5=&-/X8D=N(W,954]AS>ZW3
-M\FK_[&9WQF]HW-H+%32H)T,O[NXP;M.ZKX?#?A<7K965-CB^=X5%QZY:]66O
-M?>#BO-6NT'+3>50L.GJIJ;2%&,=6Y.'-Y:BUIM^E_CAW#\9AUL-F/6RO]1#]
-MNW:DU%K5OD*'GNN#L9G7%A)KK03R;G4YI\#P['Z,6QTT321C7FK>Z&Q$V=N"
-M.+,.3:U%G$=5)FTI.GW>^YC[T:$Z+QN0:_W+=KQLA5AMO!ZH`X(#G!ZW]9`Z
-M5UQ$VZJI5DVU]<;6M&V$T,A=<U_.1[C:U!JF8IPV1&/8M:9K1;0]>L2\HRB;
-MC[;MW!X=9&G)-XQ$'2[IX8D.#/A;XQX](:%<SL:@IT8O!#U0V[FW+EAJMVM_
-M2\VM_HC^4F#4#FR'+OW0Y5+/&J=YWEN\HH\TI_U<:M(N;(?.M:Z^9S#OYZAK
-M&;3AL-[W2&J;I<3S8&A\M)S"$6H7]_">UU;[O??!UEO13L,H4S^'I.C9?VE&
-M/1F6>G*7I9W=,O?`:XG\N15NTA/T7'9K[]I2ZNFJ1VX]FMII.^5SH<[JB=MC
-MHA6Z]3Z::U0D#95V/K1FK$<_E<[3I<;7^G*XT3(W]E%OA=9#ZZAC]%\,ND.D
-M[>BMT/(7TP+7]:[%Q!#J+_/Q/\<AQ+;S<=*/:Q'JT&D;HM([;.^I=2I!OX06
-M2C7D-=--ZVIC.Z>1>9]3G,XI/?.EG4U):E0@SW8VQA8%&+P:!OB[1X'3B:4-
-M?\^ASC"AAIRKH;]=*M!F8WLY4QU"Z$C&M51>?ZG50MRDMY)SQ\*',Q<.$>/#
-M/,:TC"ZM)A2<E0F6#<"-]M$^VD?[:!_MNR7[QC2`,>I'_:@?]:-^U.^F]',#
-MP*)^U(_Z43_J1_UN23_CPP"9R!_Y(W_DC_R1O]OB+P\PB/R1/_)'_L@?^;LI
-M_H(,L(;\D3_R1_[('_G[1OFS#O[)9)?16KL:FQ):;W?CCE'*`%%H(`VD@320
-M!M+`&S0P#R"#!M)`&D@#:2`-O$$#IT$A(()$D`@202)(!&\/05P'6JX"0P-I
-M(`VD@33P%@VT@T[=-)`&TD`:2`-IX,T9B*DF#CHS4T$J2`6I(!6D@C>HH'>#
-M3KE4D`I202I(!:G@#2H8PJ#S*!6D@E20"E)!*GB#"D:]%N1:,520"E)!*D@%
-M;U-!/^A41P6I(!6D@E20"GZC"F*F<1.&&ZE%9\@I>G2`L4B%*=M+1.B;J!OW
-M45)1C_PDF)^Q;YH07AXI,9%YFSV<"B5HC.0<)S3-ER(:<B[J.>ZG,)LXN64,
-M6>PZNA!08,DP5\063.M)!ITHR2[9);MDE^R27;+[?[)KE-VQLHMS+ZTF3;C0
-M%<E)V74)M4QIT&F0[))=LDMVR2[9_5;9=;&(!TMV"CI%.EN<FN9!Y:;S4)Z\
-M3CM%-^]C=@G#8:Q,*`/C*['::QV2ZW0F(2A7-N6(J6^4&++Z:WU):`%PGCQJ
-MD6+!A:^%[6G!,=:%=837%L7[$L!\L$X)Q\6O<&4>*DR%J3`5IL)4^)H*?_WT
-MV6:T9!W=-D;Q12^S4]"G8,0-.C\18`),@`DP`2;`!/B/`UA\*H/./`28`!-@
-M`DR`"3`!OAK`+[X(MCF54`LO,#@$_1`Z%KWQ.>L[4H0K(M%@&DR#:3`-IL%_
-ML,&HKQ]T+J#!-)@&TV`:3(-I\/4,KO=CC?U^+/$I%RT_VK2-Q4WZ>70.X3"X
-M%$Z#GMETF`[383I,A^GPM^JPM5-*ZI*SH!00AH2>0]L<S,2L[;+7P#&AZ/9]
-ME`";,4N[B*)!L4NY/98T(3UF-$`=HCZ8Y.+D$2ZI)%\?3?)%LL:?.)W`1G$N
-MA-DXGQ*NB5VTV:VCE,DE?2C*9:?X!U<_FK9Z?Q:7IB+'Y)@<DV-R3(ZOSK&U
-M^JR2LT&OC5TJH8!CA+.NU(%]I7*<+7HW).68:V218W),CLDQ.2;'5^=X*E(Y
-MAL?@..,:&!R''*QR[";;.$[*<=#'A[EV%CDFQ^28')-C<GQMCEVQT#AD*<L8
-MD%72-2Q]P;R`ZJ3Z-74,F.K%VT%CFQ;38EI,BVDQ+:;%U[78)OW>6*+5Y:1=
-M\6X=D][!97/P#NA-DRZJY6UP@P8H*2;%I)@4DV)23(JO3+'/2K%8"XJ]C0&7
-MQ=$IQ=&'1G$!Q9+BH%%&BDDQ*2;%I)@4D^+K4ER\KC3MIZ02QZF@`EYOW<I9
-MU]F"Q,Y"8E=48BZT18DI,26FQ)28$O\I$J>@+QIV7&Z+$E-B2DR)*3$EOK+$
-M1B4>N\311K<:R:(?3Y<0VS?%25^_Y/2F+<=5MT@Q*2;%I)@4D^(_A^(<IC+H
-M")!B4DR*23$I)L6D^+H4UYNVQG[35HQ30@V"T^>*2XJI6IP#LDE1+XNYZA8M
-MIL6TF!;38EI\=8OU6::Q/\L4L^B7Q3GKM\4EQ_9M<;'(IDQYT'ZAQ;28%M-B
-M6DR+:?%U+:YK?(Q]C8\<I[":6!\LEBGF^C23=04UMT'OH>9Z6[28%M-B6DR+
-M:?&U+6[+7XY]^<N$FMK52)EL`<?)6JL<!YL@G?B4!JTM/:;'])@>TV-Z3(^O
-M['%].\38WPZ1)%N]@ZNXY-1CL?46KB#Z#F-),0\_>RZ\18_I,3VFQ_28'E_=
-MX_KRQ+&_/#'YH&\R=E+?UB1YDOK5<4@6T@74;/CPTP_O?SR=K#R<GI^>/ST]
-4S\__>GIE7[_[R_!?_:LR?'4F`0``
+begin 600 assPrimes.res.gz
+M'XL(""P[>U,``V%S<U!R:6UE<RYR97,`[=W+BAS)%0;@?3U%,7BA(3JDB!-W
+MB];"S$9@!C.:W2!$7DW#C#RHVQC\]/Y/1%9+>*M:=?T@U%V9<<\3\9'5E5$?
+M?OWI_<_G\]F_.__]_=_./SP]/KW^_6'^X>T9OWUZ^/SP].K'MR?]>7[W[CP]
+M/O[CR\,?V^/KS]M_7C\^34^G#T<!<A2`)'_V)/_=OOQK??ACE/:<++P[?WGX
+M_,_S+^?[L[M[-=W-=\O=>K?=[3_>K7]^31??G1_6;?K]_/Y\_WPPO3[+/AO9
+M%K.*F?#O[OE<UG,+SJU&YLG,7\\4/;.:38PLDUG,+%_/53VW&5DG@WS+-[G:
+MZ_..'-MD]/1LEJ^YO--<D]EQ&JU9E^=F>__-&+UZCY'[S7_\ZPG%?<(O]\MJ
+MYLU,N_%O9!]'!4=1S8S:I\V@QFT<#Q_OY\5,:'9/O8ZC$4>1>EIZ;];=+.-X
+M^G@_S6;=S-)3S^-HQE'1D9(%?9AW,XWCY>/]NNF)7<_L9M[%IC<A'TVJ."TH
+M:A,[X8RV5?]O1\L:VH":)I0PH04;VHPD6_]_U>I]/5KE'1J@2=&J#96M(RF.
+MX/]E)#V:ZC$Z:[!A1J5YVG:[XP5^^#?QZ+H7K5<L.K];E&91FETTA;_TUP>M
+MKX_/9K9@XHK.+4>E@@X=R3"*6]A-6+7MRQYP/N196^5E7)QX#(7'P"[:]'GK
+M8Q#RM/:AT'K+Y:IX#/3<4VD/<1U'E7LTS[F6GGZ3_N,R/+@.DV:;--O6VR'Z
+MN@^D]%;UL<*`7MJ#:S,M(R26W@B4/=IR28'+LT6;UW[1-)'8.O>R,=B(LC<-
+M<>8#NMJKN%Q5<=I3#/JT'=<\VH#F?-N!VMO?UOW;7HC7SFM&O2#($#3?>H34
+MI>$BVE=-M6BJ]>AL3SNN$#JY:>GS)4?H7>UA*B9H1S2&P^BZ-D3[HSFF#57Y
+MNH]CE_[H19:1?,65Z)=+CO#$`":\UKC'2$AJS[,QZ=0X*L$(]'YN8PCF/NPZ
+MWM)+ZS]R?*XPZP".K/.1=7YN9X_3.FTC7C%&6M)VJ;7H$(ZL4V]K/`J8MDO4
+MC0+&Y?`Q'I$T#DO+EXNA\3%*2GOJ0WR$][2,UF_'&*Q'+\8TS.*..21-9_]S
+M-_IDF/OD;O.8W3(=@3<2Q4LO@M,)>JE[]'<9*76Z:L[UB*8Q;5V]5!J\3MPC
+M)D:EZS%&4X^*HJ$RYL/HQK(?4^FR7&I\+=]>;O0LV..JCTI[UG[5<?6_N>@!
+MD;9AM-(H7\P(W'`,+1:&U'^9]O_+AQ!;+_GDR#<B-&#05D1E##A^I-:E!..2
+M1BCUD-="5VVKSV-.H_!C30FZIAR%SV,V%>E1@3+';,PC"G#Q>AC@]1$%01>6
+M<?F/$OH*DWK(A1[ZZW,#QFKLGV=J0`CMQ821*NHOO5F(F_)&:CVPB.G"14#$
+MQ,EX/]L0%EME-0%\["?81OI('^DC?:2/]-T0?3:T$QBC?M2/^E$_ZD?];D@_
+MXT_PBO@1/^)'_(@?\;LE_,()+A$_XD?\B!_Q(WZWA%\\02#B1_R('_$C?L3O
+MIO##K5^A?M2/^E$_ZD?]7JI^"`H3PFQ;6ZS$O)J6-Q-V&\L)G!!``D@`"2`!
+M)("W!:!)[00O""`!)(`$D``2P!<*H,3)Y#Q;W^IB(U(;WT!(1KLR;@(!`1$D
+M@D20"!)!(GB#"/J3KNY$D`@202)(!(G@S2'8;P2Y!0P-I($TD`;2P!LT,+:3
+MKLLTD`;20!I(`VG@K1EH2CCI@DL#:2`-I($TD`;>G(%-_Q[(;6%H(`VD@320
+M!MZ@@;ZFDRZ01)`($D$B2`2)X.TAV.\$N4L,$22"1)`($L$7BZ#U2:^V$>]T
+M@?0M9EUKG)>()3N5C#7=^N@UEFQ&#_2J9N<J:I?BFG8DBZZ^-KAYMS&+QHAH
+MG!H)Q2'D@N38U[3)ZO/X.;L%C?.KE5;:9JMW#6/HLOX)DCO3$%VB2W2)+M$E
+MNM^-KKEL@E,3;G)1)-`MM71T@Z);].U>[H9#=(DNT26Z1/?EHBM.HJ);.[I(
+MW]>:7`,RVI)K570K7@+="H1Q5<6'B!7:A.QU8403O*YE4='-OL=(AME8I\$S
+M0BZ&--8TI[>Z;K8BJ!!RKS96%U&^JZ'N)E9_TN6,[))=LDMVR2[9);O?R:Y1
+M=LU@USE9K`0!O&A8A[<4P)N=PLL]?P@OX26\A)?POEQX8TH*;PX*;TBX\<1:
+MDUW0X;>^2%-YHP2=$]8WC=A-;U-%Z:U>"KH2:^ZK65-Z?:@:)B$GM;=XK_:V
+MTG19JQ&WO!*\FTW,*2S&EQ22@A]R@^@Q2=4G;/))UQWR2W[)+_DEO^27_'X_
+MOT;Y-9U?V\05#$9N3OE%N:HO(FM7DI5?[G1$?LDO^26_Y/?E\IM=4944QM7&
+M4BKZ;ZJ+*!_3/;@<=9;FJ,-I)171V9ZC"UT#5S5&\+K&JLN9=(#Q`H$2J[;#
+M-%BM<1<<*NYO4D\VM3@C<8J+T9Q8#()DMUF,OK[[7%(YZ3I`?^DO_:6_])?^
+MTM_K^(MTJNUL!84LQD<7^T>K,9#*;]#'>D7YY09/Y)?\DE_R2W[)[Y7XQ>WN
+M9#J_01]7TI)57X_9J/IZZ>\^GW124E_J2WVI+_6EOM3W.OKJF\^FO_D<J]?=
+MK/198=OZ(T=!'PA&#MWA7[BG%?DEO^27_)+?E\NOKPKB8B1)?^@HAI`Z:A$W
+MI!7+=FZ^B3YWE`%IA<&EP->E?P[+]58$2:ZO,"VF&'6CC:P*)[S0>(G99]UK
+MH\;8-]MH/NN4+]7IQZ!]3&XV*4F4Q?CL?7;0.+>6-]N:B%*7:VXGG2($F2`3
+M9(),D`DR0;XVR"'721]!S@*0?2X5("?<@4>`'!+2`F3O(W**Z*[/PKVP"#)!
+M)L@$F2`3Y*N#'%.-$Q:Z[/*,D\6[Q32`+*LM.%KA<8U>'U;R_5L8`C?)HL?T
+MF![38WI,CZ_OL8ZA];[Z"(]S"'$QM06IJ\VU88C@<8CZX6DGDDX::O28'M-C
+M>DR/Z3$]OK;'/HEZC'M@>)R0#![G4#(\+M5+]]@[-+[Z=M(X(<?DF!R38W),
+MCLGQE3D.Z#8X=EGT[6HIQ2WZ.6ZTW>:D!8)CT6]TR"WKN]7<6XL<DV-R3([)
+M,3F^/L=(-=DFT<W&UXP5SQ3GHX/&/A;]='7U_5GC[(+>'7.K+7),CLDQ.2;'
+MY/C:')O.L>D<(T.5NMA<LG[I$BI0C?6[BS&V+335F#MO46-J3(VI,36FQM?7
+M6-^K-N.]:AM=JWE!T2W)JCCK)[ER</V37+5_DHM;<9%C<DR.R3$Y)L=7Y[A_
+MDLN,3W)9U)IEL374E/5;(:H^>)PE1'W0J17]TS&WYB+'Y)@<DV-R3(ZOS[&.
+MH1D/.MD84W+@.%?=)U-$/\>5?=/'CF,2U9C[<E%C:DR-J3$UIL;7UUBW`3%C
+M&Q`;<Y.\V"8%L6;$]0]R99S$X*:B7QL1N"L7.2;'Y)@<DV-R?'6.^S:99FR3
+MB4IJBQB;V$J-6GG0;W%J*0:'G"VG=OHM<ELN@DR0"3)!)L@$^?H@ZQ=)F/%%
+M$K:@615CDS`6#I67_KU.+07](HD0<VZG#[_^]/[G\]G+N_/3X].GQZ?IZ=^/
+0K_R/;_]R^A\[8R?//"8!````
 `
 end

Tst/Manual/assPrimes.stat

@@ -1 @@
-1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:1480252
-1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:1826816
-1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:2394052
-1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:739
+1 >> tst_memory_0 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:1033400
+1 >> tst_memory_1 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2461696
+1 >> tst_memory_2 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2461696
+1 >> tst_timer_1 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:1015

Tst/Manual/modStd.res.gz.uu

@@ -1 @@
-begin 644 modStd.res.gz
-M'XL("(@W(5```VUO9%-T9"YR97,`=5--3X-`$+WW5TR,AR6[0F?9!9NF'(P7
-MB/%@O9G&5"`54ULC:X3]]<YB"UC3TW9VWKR/V;)\O$WO`0`3N$MOX,+4QM]6
-M+Q=SH%_/U:XRS)M/W`E)`N_[8FD*?U=^^[59F\GR,"T/T]2OJ=\1],TP@<]J
-MMX$'A`5,!6M$*ZPPGB@^!I!*H"K*]192`H5-R!O)40!BJWD;<BE`6\6MY&J8
-MT<>9C&9^K;'4&_I1`ME\DCWA:D&$&(2.,PCI1JX6Q(:!=H2!IIMPM2`E#$B0
-MU.CH6>*D\_2Z?]]O6$J^!X'KY)ST[+^T<8<Y43>=OE$G#NC:>3#Z2(C3XQ+E
-M:(FTPKK71!RO\&V=[U]80\N+N(UYT]K!'<I^<3BR+U!,1R!ZM@PI`W8A6A[;
-MR!5DOK$\:K4KG&?+=:-<H:BCKV**%;M24R^B,OHM(PI]W9.K8YRPB],P]'WE
-MB>WPCT`]CI.W^;;*F1KYB\Z$&$'B'B+/YZ1'K"M;LL^R^,I+EJ'(I$?]:8^8
-=G2"DR/`/0M+KN,_%?1-?-2,+EY,?)':#3%D#````
+begin 600 modStd.res.gz
+M'XL(");^>E,``VUO9%-T9"YR97,`=5/+;MLP$+S[*Q9!#A2H2%Y2E!P8YJ'H
+M14+10]U;812.I*8*%#N(:$3BUW?I!Z4XS8GD/F9GAN3ZY]?\.P"@AF_Y%[@Q
+MG8G:YN%F";3[W>P:PX+ES*V@-3SOJ[6IHEW]%G5F:V;K<[<X=U.^H_P1P">E
+MAM=F]P@_$%8P#X'UX1#:T`0A5"]C6:*AJ>IM"SF5R5[R7G`,`7%0?)!<A*!L
+MPJW@R=BC+CT%]9S(L3P8\ZF&8CDK?N%F18`82X<92XJ(S8K0,%8.,%84D9L5
+M3<*8!M(T6CQ*IH^<_NZ?]X\L#\%,)BST9[/O/\XV;C%7X\V1@$FN*%#8D3#J
+M`HAS#7Z/T=E3,?74.=IY!BBFCCYMR_T#Z\G+E-N,]X,=N:+\GX\AS"<ER43.
+MP#.;GE3TEJ?#Q3[+5>]T)!17=QFIR^BD*)/2*3V>4E*^\*AJHBF]:)(G33W#
+M*$I(4SN^$LRFFLJA;)N2)1.:"Z\$WTG!8$EW$L=0U7^VA]8_7;SW#>(S[8*<
+M[QI;L]>Z.I0U*^A9%B*@@KDOP:L2>JX%OB^AZW!_RGV<0\>(T.WL'P97UU]^
+#`P``
 `
 end

Tst/Manual/modStd.stat

@@ -1 @@
-1 >> tst_memory_0 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:269264
-1 >> tst_memory_1 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:669168
-1 >> tst_memory_2 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:747000
-1 >> tst_timer_1 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:14
+1 >> tst_memory_0 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:395620
+1 >> tst_memory_1 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2322432
+1 >> tst_memory_2 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2408400
+1 >> tst_timer_1 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:162

Tst/Manual/modStd.tst

@@ -1 +1 @@
 LIB "tst.lib"; tst_init();
 LIB "modstd.lib";
-ring R1 = 0,(x,y,z,t),dp;
+ring R1 = 0, (x,y,z,t), dp;
 ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
 ideal J = modStd(I);
 J;
-I = homog(I,t);
+I = homog(I, t);
 J = modStd(I);
 J;
-ring R2 = 0,(x,y,z),ds;
+
+ring R2 = 0, (x,y,z), ds;
 ideal I = jacob(x5+y6+z7+xyz);
-ideal J1 = modStd(I,1,0);
-J1;
-ring R3 = 0,x(1..4),lp;
+ideal J = modStd(I, 0);
+J;
+
+ring R3 = 0, x(1..4), lp;
 ideal I = cyclic(4);
-ideal J1 = modStd(I,1);
-ideal J2 = modStd(I,1,0);
-size(reduce(J1,J2));
-size(reduce(J2,J1));
+ideal J1 = modStd(I, 1);   // default
+ideal J2 = modStd(I, 0);
+size(reduce(J1, J2));
+size(reduce(J2, J1));
 tst_status(1);$

Tst/Manual/s.lst

@@ -1026 +1026 @@
 Maxord.tst
 minpoly.tst
-modHenselStd.tst
 module_containment.tst
 modulo_BR_PLURAL_BR.tst
@@ -1157 +1156 @@
 minAssGTZ.tst
 mindist.tst
-modS.tst
 multiplylist.tst
 nonMonomials.tst

Tst/New.lst

@@ -51 +51 @@
 New/qring_ZmtoZmn_errorCoprime.tst
 New/qring_ZtoZm.tst
+New/AnnExt_R_bug.tst

Tst/Rest.lst

@@ -323 +323 @@
 Short/lres_s.tst
 Short/minor_s.tst
-Short/modstd.tst
+Short/modstd_s.tst
 Short/modulo_s.tst
 Short/monodromy_s.tst

Tst/Short.lst

@@ -188 +188 @@
 Short/lres_s.tst
 Short/minor_s.tst
-Short/modstd.tst
+Short/modstd_s.tst
 Short/modulo_s.tst
 Short/monodromy_s.tst
@@ -260 +260 @@
 ;MP Short/stratify.tst
 Short/string.tst
-;;; Short/symodstd.tst ; the test  is also in Long/
 Short/test_c_dp.tst
 Short/triang_s.tst

Tst/Short/bug_charseries.res.gz.uu

@@ -1 @@
-begin 644 bug_charseries.res.gz
-M'XL("%?:;%,``V)U9U]C:&%R<V5R:65S+G)E<P#5E%%OFS`0Q]_S*4[1'@A0
+begin 640 bug_charseries.res.gz
+M'XL(""-R>U,``V)U9U]C:&%R<V5R:65S+G)E<P#5E%%OFS`0Q]_S*4[1'@A0
 MBFU(2".8-&T/E:9-2BI54]5$)#&I-4:H(=K*I]\%!VP13=IK><'<_W>'??>'
 MU</G^V\`0!+X>O\)QG55>[G8CA>CU46A"6!P(PI16Y/%Z'R')('MZ;#9O:2R

Tst/Short/bug_charseries.stat

@@ -1 @@
-1 >> tst_memory_0 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:236720
-1 >> tst_memory_1 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2338816
-1 >> tst_memory_2 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2375480
-1 >> tst_timer_1 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:12
+1 >> tst_memory_0 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:272136
+1 >> tst_memory_1 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2342912
+1 >> tst_memory_2 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2375984
+1 >> tst_timer_1 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:3

Tst/Short/ok_s.lst

@@ -218 +218 @@
 minor_s
 modular_s
-modstd
+modstd_s
 modulo_s
 monodromy_s

Tst/regress.lst

@@ -1034 +1034 @@
 Manual/Maxord.tst
 Manual/minpoly.tst
-Manual/modHenselStd.tst
 Manual/module_containment.tst
 Manual/modulo_BR_PLURAL_BR.tst
@@ -1165 +1164 @@
 Manual/minAssGTZ.tst
 Manual/mindist.tst
-Manual/modS.tst
 Manual/multiplylist.tst
 Manual/nonMonomials.tst

factory/cf_gcd.cc

@@ -958 +958 @@
 content ( const CanonicalForm & f, const Variable & x )
 {
+    if (f.inBaseDomain()) return f;
     ASSERT( x.level() > 0, "cannot calculate content with respect to algebraic variable" );
     Variable y = f.mvar();