passagemath-singular 10.6.31rc3__cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

sage_wheels/share/singular/LIB/modstd.lib

@@ -0,0 +1,1024 @@
+///////////////////////////////////////////////////////////////////////////////
+version="version modstd.lib 4.3.0.1 Mar_2022 "; // $Id: f61b67b01efbf6f676552231c956f9e079dc9c20 $
+category="Commutative Algebra";
+info="
+LIBRARY:  modstd.lib      Groebner bases of ideals/modules 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
+
+OVERVIEW:
+  A library for computing Groebner bases of ideals/modules 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
+  modGB(cmd,I); standard basis of I using modular methods via cmd
+  modSyz(I);    syzygy module of I  using modular methods
+  modIntersect(I,J); intersection of I and J using modular methods
+";
+
+LIB "polylib.lib";
+LIB "modular.lib";
+
+proc modStd(def I, list #)
+"USAGE:   modStd(I[, exactness]); I ideal/module, 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(default), 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);
+    if (attrib(basering,"global")==0)
+    {
+      if (noether!=0) { option(infRedTail);}
+      else
+      { def II=I; attrib(II,"isSB",1);
+        if (highcorner(II)!=0) { option(infRedTail);}
+      }
+    }
+
+    /* choose the right command */
+    string command = "std";
+    if ((system("nblocks")>2) || (npars(basering) > 0))
+    { command = "Modstd::groebner_norm"; }
+
+    /* call modular() */
+    if (exactness)
+    {
+      if(hasCommutativeVars(basering) && (attrib(basering,"global")==1))
+      {
+        I = modular(command, list(I), primeTest_std,
+            deleteUnluckyPrimes_std, pTest_std, finalTest_std_comm);
+      }
+      else
+      {
+        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));
+}
+
+proc modGB(string command, def I, list #)
+"USAGE:   modGB(method, I[, exactness]); I ideal/module, exactness int
+          method can be: std, slimgb, sba
+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(default), 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 modGB; shows an example"
+{
+    /* read optional parameter */
+    int exactness = 1;
+    if (size(#) > 0)
+    {
+        if (typeof(#[1]) != "int")
+        {
+            ERROR("wrong optional parameter");
+        }
+        exactness = #[1];
+    }
+
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+    option(redTail);
+
+    /* call modular() */
+    if (exactness)
+    {
+      if(hasCommutativeVars(basering) && (attrib(basering,"global")==1))
+      {
+        I = modular(command, list(I), primeTest_std,
+            deleteUnluckyPrimes_std, pTest_std, finalTest_std_comm);
+      }
+      else
+      {
+        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 = modGB("slimgb",I);
+    J;
+    I = homog(I, t);
+    J = modGB("slimgb",I);
+    J;
+
+    ring R3 = 0, x(1..4), lp;
+    ideal I = cyclic(4);
+    ideal J1 = modGB("slimgb",I, 1);   // default
+    ideal J2 = modGB("slimgb",I, 0);
+    size(reduce(J1, J2));
+    size(reduce(J2, J1));
+}
+
+proc modSyz(def I)
+"USAGE:   modSyz(I); I ideal/module
+RETURN:   a generating set of syzygies of I
+NOTE:     The procedure computes a the syzygy module of I (over the rational
+          numbers) by using modular methods with high probability.
+          The property of being a syzygy is tested.
+SEE ALSO: modular
+EXAMPLE:  example modSyz; shows an example"
+{
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* choose the right command */
+    string command = "syz";
+
+    /* call modular() */
+    module M = modular(command, list(I), primeTest_std,
+         deleteUnluckyPrimes_std, pTest_syz);
+
+    /* return the result */
+    option(set, opt);
+    return(M);
+}
+example
+{
+    "EXAMPLE:"; echo = 2;
+    ring R1 = 0, (x,y,z,t), dp;
+    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
+    modSyz(I);
+    simplify(syz(I),1);
+}
+
+proc modIntersect(def I, def J)
+"USAGE:   modIntersect(I,J); I,J ideal/module
+RETURN:   a generating set of the intersection of I and J
+NOTE:     The procedure computes a the intersection of I and J
+          (over the rational numbers) by using modular methods
+          with high probability.
+          No additional tests are performed.
+SEE ALSO: modular
+EXAMPLE:  example modIntersect; shows an example"
+{
+    /* save options */
+    intvec opt = option(get);
+    option(redSB);
+
+    /* choose the right command */
+    string command = "intersect";
+
+    /* call modular() */
+    def M = modular(command, list(I,J), primeTest_std,
+         deleteUnluckyPrimes_std);
+
+    /* return the result */
+    option(set, opt);
+    return(M);
+}
+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 = maxideal(2);
+    modIntersect(I,J);
+    simplify(intersect(I,J),1);
+}
+
+/* compute a normalized GB via groebner() */
+static proc groebner_norm(def 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 */
+    def I = simplify(args[1], 2);
+
+    /* clear denominators and count the terms */
+    def J=I; // dummy assign, to get the type of I
+    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);
+    def 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;
+    def L=modresults[1]; // dummy assign to get the type of 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], 5)) == 0
+            && size(reduce(cat[j][1], L, 5)) == 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);
+}
+////////////////////////////////////////////////////////////////////////////////
+
+static proc cleardenomModule(def I)
+{
+  int t=ncols(I);
+  if(size(I)==0)
+  {
+      return(I);
+  }
+  else
+  {
+    for(int i=1;i<=t;i++)
+    {
+      I[i]=cleardenom(I[i]);
+    }
+  }
+  return(I);
+}
+
+static proc pTest_syz(string command, alias list args, alias def result, int p)
+{
+  module result_without_denom=cleardenomModule(result);
+  return(size(module(matrix(args[1])*matrix(result_without_denom)))==0);
+}
+
+/* test if 'command' applied to 'args' in characteristic p is the same as
+   'result' mapped to characteristic p */
+static proc pTest_std(string command, alias list args, alias def 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);
+    def Ip = fetch(br, args)[1];
+    def 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, commutative ring */
+static proc finalTest_std_comm(string command, alias list args, def 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 */
+    //def G = std(result);
+    //if (reduce_parallel(G, result)) { return(0); }
+    //return(1);
+    return(system("verifyGB",result));
+}
+
+/* test if 'result' is a GB of the input ideal, generic */
+static proc finalTest_std(string command, alias list args, def 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); }
+    }
+
+    option(noredSB,noinfRedTail);
+    /* test if result is a GB */
+    def 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(def I_reduce, def 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
+ * 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)
+{
+   attrib(J,"isSB",1);
+   return(reduce(I,J,1));
+}
+
+proc isIncluded(ideal I, ideal J, list #)
+"USAGE:  isIncluded(I,J); I,J ideals
+RETURN:  1 if J includes I,
+@*       0 if there is an element f in I which does not reduce to 0 w.r.t. J.
+EXAMPLE: example isIncluded; shows an example
+"
+{
+   def R = basering;
+   setring R;
+
+   attrib(J,"isSB",1);
+   int i,j,k;
+
+   if(size(#) > 0)
+   {
+      int n = #[1];
+      if(n >= ncols(I)) { n = ncols(I); }
+      if(n > 1)
+      {
+         for(i = 1; i <= n - 1; i++)
+         {
+            //link l(i) = "MPtcp:fork";
+            link l(i) = "ssi:fork";
+            open(l(i));
+
+            write(l(i), quote(redFork(eval(I[ncols(I)-i]), eval(J), 1)));
+         }
+
+         int t = timer;
+         if(reduce(I[ncols(I)], J, 1) != 0)
+         {
+            for(i = 1; i <= n - 1; i++)
+            {
+               close(l(i));
+            }
+            return(0);
+         }
+         t = timer - t;
+         if(t > 60) { t = 60; }
+         int i_sleep = system("sh", "sleep "+string(t));
+
+         j = ncols(I) - n;
+
+         while(j >= 0)
+         {
+            for(i = 1; i <= n - 1; i++)
+            {
+               if(status(l(i), "read", "ready"))
+               {
+                  if(read(l(i)) != 0)
+                  {
+                     for(i = 1; i <= n - 1; i++)
+                     {
+                        close(l(i));
+                     }
+                     return(0);
+                  }
+                  else
+                  {
+                     if(j >= 1)
+                     {
+                        write(l(i), quote(redFork(eval(I[j]), eval(J), 1)));
+                        j--;
+                     }
+                     else
+                     {
+                        k++;
+                        close(l(i));
+                     }
+                  }
+               }
+            }
+            if(k == n - 1)
+            {
+               j--;
+            }
+            i_sleep = system("sh", "sleep "+string(t));
+         }
+         return(1);
+      }
+   }
+
+   for(i = ncols(I); i >= 1; i--)
+   {
+      if(reduce(I[i],J,1) != 0){ return(0); }
+   }
+   return(1);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring r=0,(x,y,z),dp;
+   ideal I = x+1,x+y+1;
+   ideal J = x+1,y;
+   isIncluded(I,J);
+   isIncluded(J,I);
+   isIncluded(I,J,4);
+
+   ring R = 0, x(1..5), dp;
+   ideal I1 = cyclic(4);
+   ideal I2 = I1,x(5)^2;
+   isIncluded(I1,I2,4);
+}
+
+proc deleteUnluckyPrimes(list T, list L, int ho, list #)
+"USAGE:  deleteUnluckyPrimes(T,L,ho,#); T/L list of polys/primes, ho integer
+RETURN:  lists T,L(,M),lT with T/L(/M) list of polys/primes(/type of #),
+         lT ideal
+NOTE:    - if ho = 1, the polynomials in T are homogeneous, else ho = 0,
+@*       - lT is prevalent, i.e. the most appearing leading ideal in T
+EXAMPLE: example deleteUnluckyPrimes; shows an example
+"
+{
+   ho = ((ho)||(ord_test(basering) == -1));
+   int j,k,c;
+   intvec hl,hc;
+   ideal cT,lT,cK;
+   lT = lead(T[size(T)]);
+   attrib(lT,"isSB",1);
+   if(!ho)
+   {
+      for(j = 1; j < size(T); j++)
+      {
+         cT = lead(T[j]);
+         attrib(cT,"isSB",1);
+         if((size(reduce(cT,lT,5))!=0)||(size(reduce(lT,cT,5))!=0))
+         {
+            cK = cT;
+            c++;
+         }
+      }
+      if(c > size(T) div 2){ lT = cK; }
+   }
+   else
+   {
+      hl = hilb(lT,1);
+      for(j = 1; j < size(T); j++)
+      {
+         cT = lead(T[j]);
+         attrib(cT,"isSB",1);
+         hc = hilb(cT,1);
+         if(hl == hc)
+         {
+            for(k = 1; k <= size(lT); k++)
+            {
+               if(lT[k] < cT[k]) { lT = cT; c++; break; }
+               if(lT[k] > cT[k]) { c++; break; }
+            }
+         }
+         else
+         {
+            if(hc < hl){ lT = cT; hl = hilb(lT,1); c++; }
+         }
+      }
+   }
+
+   int addList;
+   if(size(#) > 0) { list M = #; addList = 1; }
+   j = 1;
+   attrib(lT,"isSB",1);
+   while((j <= size(T))&&(c > 0))
+   {
+      cT = lead(T[j]);
+      attrib(cT,"isSB",1);
+      if((size(reduce(cT,lT,5)) != 0)||(size(reduce(lT,cT,5)) != 0))
+      {
+         T = delete(T,j);
+         if(j == 1)
+         {
+            L = L[2..size(L)];
+            if(addList == 1) { M = M[2..size(M)]; }
+         }
+         else
+         {
+            if(j == size(L))
+            {
+               L = L[1..size(L)-1];
+               if(addList == 1) { M = M[1..size(M)-1]; }
+            }
+            else
+            {
+               L = L[1..j-1],L[j+1..size(L)];
+               if(addList == 1) { M = M[1..j-1],M[j+1..size(M)]; }
+            }
+         }
+         j--;
+      }
+      j++;
+   }
+
+   for(j = 1; j <= size(L); j++)
+   {
+      L[j] = bigint(L[j]);
+   }
+
+   if(addList == 0) { return(list(T,L,lT)); }
+   if(addList == 1) { return(list(T,L,M,lT)); }
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   list L = 2,3,5,7,11;
+   ring r = 0,(y,x),Dp;
+   ideal I1 = 2y2x,y6;
+   ideal I2 = yx2,y3x,x5,y6;
+   ideal I3 = y2x,x3y,x5,y6;
+   ideal I4 = y2x,11x3y,x5;
+   ideal I5 = y2x,yx3,x5,7y6;
+   list T = I1,I2,I3,I4,I5;
+   deleteUnluckyPrimes(T,L,1);
+   list P = poly(x),poly(x2),poly(x3),poly(x4),poly(x5);
+   deleteUnluckyPrimes(T,L,1,P);
+}
+
+proc primeTest(def II, bigint p)
+{
+   if(typeof(II) == "string")
+   {
+      ideal I = `II`.Ideal;
+   }
+   else
+   {
+      ideal I = II;
+   }
+
+   I = simplify(I, 2);   // erase zero generators
+
+   int i,j;
+   poly f;
+   number cnt;
+   for(i = 1; i <= size(I); i++)
+   {
+      f = cleardenom(I[i]);
+      if(f == 0) { return(0); }
+      cnt = leadcoef(I[i])/leadcoef(f);
+      if((bigint(numerator(cnt)) mod p) == 0) { return(0); }
+      if((bigint(denominator(cnt)) mod p) == 0) { return(0); }
+      for(j = size(f); j > 0; j--)
+      {
+         if((bigint(leadcoef(f[j])) mod p) == 0) { return(0); }
+      }
+   }
+   return(1);
+}
+
+proc primeList(ideal I, int n, list #)
+"USAGE:  primeList(I,n[,ncores]); ( resp. primeList(I,n[,L,ncores]); ) I ideal,
+         n integer
+RETURN:  the intvec of n greatest primes <= 2147483647 (resp. n greatest primes
+         < L[size(L)] union with L) such that none of these primes divides any
+         coefficient occurring in I
+NOTE:    The number of cores to use can be defined by ncores, default is 1.
+EXAMPLE: example primeList; shows an example
+"
+{
+   intvec L;
+   int i,p;
+   int ncores = 1;
+
+//-----------------  Initialize optional parameter ncores  ---------------------
+   if(size(#) > 0)
+   {
+      if(size(#) == 1)
+      {
+         if(typeof(#[1]) == "int")
+         {
+            ncores = #[1];
+            # = list();
+         }
+      }
+      else
+      {
+         ncores = #[2];
+      }
+   }
+
+   if(size(#) == 0)
+   {
+      p = 2147483647;
+      while(!primeTest(I,p))
+      {
+         p = prime(p-1);
+         if(p == 2) { ERROR("no more primes"); }
+      }
+      L[1] = p;
+   }
+   else
+   {
+      L = #[1];
+      p = prime(L[size(L)]-1);
+      while(!primeTest(I,p))
+      {
+         p = prime(p-1);
+         if(p == 2) { ERROR("no more primes"); }
+      }
+      L[size(L)+1] = p;
+   }
+   if(p == 2) { ERROR("no more primes"); }
+   if(ncores == 1)
+   {
+      for(i = 2; i <= n; i++)
+      {
+         p = prime(p-1);
+         while(!primeTest(I,p))
+         {
+            p = prime(p-1);
+            if(p == 2) { ERROR("no more primes"); }
+         }
+         L[size(L)+1] = p;
+      }
+   }
+   else
+   {
+      int neededSize = size(L)+n-1;;
+      list parallelResults;
+      list arguments;
+      int neededPrimes = neededSize-size(L);
+      idealPrimeTest Id;
+      Id.Ideal = I;
+      export(Id);
+      while(neededPrimes > 0)
+      {
+         arguments = list();
+         for(i = ((neededPrimes div ncores)+1-(neededPrimes%ncores == 0))
+            *ncores; i > 0; i--)
+         {
+            p = prime(p-1);
+            if(p == 2) { ERROR("no more primes"); }
+            arguments[i] = list("Id", p);
+         }
+         parallelResults = parallelWaitAll("primeTest", arguments, 0, ncores);
+         for(i = size(arguments); i > 0; i--)
+         {
+            if(parallelResults[i])
+            {
+               L[size(L)+1] = arguments[i][2];
+            }
+         }
+         neededPrimes = neededSize-size(L);
+      }
+      kill Id;
+      if(size(L) > neededSize)
+      {
+         L = L[1..neededSize];
+      }
+   }
+   return(L);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+   ring r = 0,(x,y,z),dp;
+   ideal I = 2147483647x+y, z-181;
+   intvec L = primeList(I,10);
+   size(L);
+   L[1];
+   L[size(L)];
+   L = primeList(I,5,L);
+   size(L);
+   L[size(L)];
+}
+
+proc modStdL(def I, list #)
+"USAGE:   modStdL(I[, exactness]); I ideal/module, 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 via an external Singular.
+       @* An optional parameter 'exactness' can be provided.
+          If exactness = 1(default), 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, modStd
+EXAMPLE:  example modStdL; shows an example"
+{
+  link l="ssi:tcp localhost:"+system("Singular");
+  write(l,quote(option(noloadLib))); // suppress "loaded..."
+  read(l); //dummy: return value of option
+  write(l,quote(load("modstd.lib","with"))); // load library
+  read(l); //dummy: return value of load
+  if (size(#)==0)
+  {
+    write(l,quote(modStd(eval(I))));
+  }
+  else
+  {
+    write(l,quote(modStd(eval(I),eval(#[1]))));
+  }
+  return(read(l));
+}
+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 = modStdL(I);
+    J;
+    I = homog(I, t);
+    J = modStdL(I);
+    J;
+
+    ring R2 = 0, (x,y,z), ds;
+    ideal I = jacob(x5+y6+z7+xyz);
+    ideal J = modStdL(I, 0);
+    J;
+
+    ring R3 = 0, x(1..4), lp;
+    ideal I = cyclic(4);
+    ideal J1 = modStdL(I, 1);   // default
+    ideal J2 = modStdL(I, 0);
+    size(reduce(J1, J2));
+    size(reduce(J2, J1));
+}
+
+////////////////////////////// further examples ////////////////////////////////
+
+/*
+ring r = 0, (x,y,z), lp;
+poly s1 = 5x3y2z+3y3x2z+7xy2z2;
+poly s2 = 3xy2z2+x5+11y2z2;
+poly s3 = 4xyz+7x3+12y3+1;
+poly s4 = 3x3-4y3+yz2;
+ideal i =  s1, s2, s3, s4;
+
+ring r = 0, (x,y,z), lp;
+poly s1 = 2xy4z2+x3y2z-x2y3z+2xyz2+7y3+7;
+poly s2 = 2x2y4z+x2yz2-xy2z2+2x2yz-12x+12y;
+poly s3 = 2y5z+x2y2z-xy3z-xy3+y4+2y2z;
+poly s4 = 3xy4z3+x2y2z-xy3z+4y3z2+3xyz3+4z2-x+y;
+ideal i =  s1, s2, s3, s4;
+
+ring r = 0, (x,y,z), lp;
+poly s1 = 8x2y2 + 5xy3 + 3x3z + x2yz;
+poly s2 = x5 + 2y3z2 + 13y2z3 + 5yz4;
+poly s3 = 8x3 + 12y3 + xz2 + 3;
+poly s4 = 7x2y4 + 18xy3z2 +  y3z3;
+ideal i = s1, s2, s3, s4;
+
+int n = 6;
+ring r = 0,(x(1..n)),lp;
+ideal i = cyclic(n);
+ring s = 0, (x(1..n),t), lp;
+ideal i = imap(r,i);
+i = homog(i,t);
+
+ring r = 0, (x(1..4),s), (dp(4),dp);
+poly s1 = 1 + s^2*x(1)*x(3) + s^8*x(2)*x(3) + s^19*x(1)*x(2)*x(4);
+poly s2 = x(1) + s^8 *x(1)* x(2)* x(3) + s^19* x(2)* x(4);
+poly s3 = x(2) + s^10*x(3)*x(4) + s^11*x(1)*x(4);
+poly s4 = x(3) + s^4*x(1)*x(2) + s^19*x(1)*x(3)*x(4) +s^24*x(2)*x(3)*x(4);
+poly s5 = x(4) + s^31* x(1)* x(2)* x(3)* x(4);
+ideal i =  s1, s2, s3, s4, s5;
+
+ring r = 0, (x,y,z), ds;
+int a = 16;
+int b = 15;
+int c = 4;
+int t = 1;
+poly f = x^a+y^b+z^(3*c)+x^(c+2)*y^(c-1)+x^(c-1)*y^(c-1)*z3
+         +x^(c-2)*y^c*(y2+t*x)^2;
+ideal i = jacob(f);
+
+ring r = 0, (x,y,z), ds;
+int a = 25;
+int b = 25;
+int c = 5;
+int t = 1;
+poly f = x^a+y^b+z^(3*c)+x^(c+2)*y^(c-1)+x^(c-1)*y^(c-1)*z3
+         +x^(c-2)*y^c*(y2+t*x)^2;
+ideal i = jacob(f),f;
+
+ring r = 0, (x,y,z), ds;
+int a = 10;
+poly f = xyz*(x+y+z)^2 +(x+y+z)^3 +x^a+y^a+z^a;
+ideal i = jacob(f);
+
+ring r = 0, (x,y,z), ds;
+int a = 6;
+int b = 8;
+int c = 10;
+int alpha = 5;
+int beta = 5;
+int t = 1;
+poly f = x^a+y^b+z^c+x^alpha*y^(beta-5)+x^(alpha-2)*y^(beta-3)
+         +x^(alpha-3)*y^(beta-4)*z^2+x^(alpha-4)*y^(beta-4)*(y^2+t*x)^2;
+ideal i = jacob(f);
+*/
+