Changeset 031e12 in git


Ignore:
Timestamp:
May 20, 2014, 6:02:52 PM (9 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
18037b5d33961444969fa5886eb3b871445e3ede6c524f33f553f9d0a11c9984e32c98732e50abb5d855100e7a4acbc1166c622954d5a517a21b6cf1
Parents:
a85671c689d223ccf164d4b692b911272a43935e7063d23887fa8ed57cbcc380059730b2c9c57a35
Message:
Merge pull request #588 from surface-smoothers/addReference.primdecint

added reference
Files:
6 added
10 deleted
22 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/assprimeszerodim.lib

    r7063d2 r031e12  
    294294
    295295   if(printlevel >= 10) { "========== Start modStd =========="; }
    296    I = modStd(I,n1);
     296   I = modStd(I);
    297297   if(printlevel >= 10) { "=========== End modStd ==========="; }
    298298   if(printlevel >= 9) { "modStd takes "+string(rtimer-RT)+" seconds."; }
     
    325325               }
    326326               TT = timer;
    327                I = std(I);
     327               I = modStd(I);
    328328               if(printlevel >= 9)
    329329               {
    330                   "std(I) takes "+string(timer-TT)+" seconds.";
     330                  "modStd(I) takes "+string(timer-TT)+" seconds.";
    331331               }
    332332               d = vdim(I);
     
    343343            }
    344344            TT = timer;
    345             I = std(I);
     345            I = modStd(I);
    346346            if(printlevel >= 9)
    347347            {
    348                "std(I) takes "+string(timer-TT)+" seconds.";
     348               "modStd(I) takes "+string(timer-TT)+" seconds.";
    349349            }
    350350            d = vdim(I);
  • Singular/LIB/modstd.lib

    r7063d2 r031e12  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="version modstd.lib 4.0.0.0 Dec_2013 "; // $Id$
    3 category = "Commutative Algebra";
     2version="version modstd.lib 4.0.0.0 May_2014 "; // $Id$
     3category="Commutative Algebra";
    44info="
    5 LIBRARY:  modstd.lib      Groebner basis of ideals
     5LIBRARY:  modstd.lib      Groebner bases of ideals using modular methods
    66
    77AUTHORS:  A. Hashemi      Amir.Hashemi@lip6.fr
    8 @*        G. Pfister      pfister@mathematik.uni-kl.de
    9 @*        H. Schoenemann  hannes@mathematik.uni-kl.de
    10 @*        A. Steenpass    steenpass@mathematik.uni-kl.de
    11 @*        S. Steidel      steidel@mathematik.uni-kl.de
     8          G. Pfister      pfister@mathematik.uni-kl.de
     9          H. Schoenemann  hannes@mathematik.uni-kl.de
     10          A. Steenpass    steenpass@mathematik.uni-kl.de
     11          S. Steidel      steidel@mathematik.uni-kl.de
    1212
    1313OVERVIEW:
    14 
    15   A library for computing the Groebner basis of an ideal in the polynomial
    16   ring over the rational numbers using modular methods. The procedures are
    17   inspired by the following paper:
    18   Elizabeth A. Arnold: Modular algorithms for computing Groebner bases.
    19   Journal of Symbolic Computation 35, 403-419 (2003).
     14  A library for computing Groebner bases of ideals in the polynomial ring over
     15  the rational numbers using modular methods.
     16
     17REFERENCES:
     18  E. A. Arnold: Modular algorithms for computing Groebner bases.
     19  J. Symb. Comp. 35, 403-419 (2003).
     20
     21  N. Idrees, G. Pfister, S. Steidel: Parallelization of Modular Algorithms.
     22  J. Symb. Comp. 46, 672-684 (2011).
    2023
    2124PROCEDURES:
    22  modStd(I);        standard basis of I using modular methods (chinese remainder)
    23  modS(I,L);        liftings to Q of standard bases of I mod p for p in L
    24  modHenselStd(I);  standard basis of I using modular methods (hensel lifting)
     25  modStd(I);    standard basis of I using modular methods
    2526";
    2627
    2728LIB "poly.lib";
    28 LIB "ring.lib";
     29LIB "modular.lib";
     30
     31proc modStd(ideal I, list #)
     32"USAGE:   modStd(I[, exactness]); I ideal, exactness int
     33RETURN:   a standard basis of I
     34NOTE:     The procedure computes a standard basis of I (over the rational
     35          numbers) by using modular methods.
     36       @* An optional parameter 'exactness' can be provided.
     37          If exactness = 1, the procedure computes a standard basis of I for
     38          sure; if exactness = 0, it computes a standard basis of I
     39          with high probability.
     40SEE ALSO: modular
     41EXAMPLE:  example modStd; shows an example"
     42{
     43    /* read optional parameter */
     44    int exactness = 1;
     45    if (size(#) > 0) {
     46        /* For compatibility, we only test size(#) > 4. This can be changed to
     47         * size(#) > 1 in the future. */
     48        if (size(#) > 4 || typeof(#[1]) != "int") {
     49            ERROR("wrong optional parameter");
     50        }
     51        exactness = #[1];
     52    }
     53
     54    /* save options */
     55    intvec opt = option(get);
     56    option(redSB);
     57
     58    /* choose the right command */
     59    string command = "groebner";
     60    if (npars(basering) > 0) {
     61        command = "Modstd::groebner_norm";
     62    }
     63
     64    /* call modular() */
     65    if (exactness) {
     66        I = modular(command, list(I), primeTest_std,
     67            deleteUnluckyPrimes_std, pTest_std, finalTest_std);
     68    }
     69    else {
     70        I = modular(command, list(I), primeTest_std,
     71            deleteUnluckyPrimes_std, pTest_std);
     72    }
     73
     74    /* return the result */
     75    attrib(I, "isSB", 1);
     76    option(set, opt);
     77    return(I);
     78}
     79example
     80{
     81    "EXAMPLE:";
     82    echo = 2;
     83    ring R1 = 0, (x,y,z,t), dp;
     84    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
     85    ideal J = modStd(I);
     86    J;
     87    I = homog(I, t);
     88    J = modStd(I);
     89    J;
     90
     91    ring R2 = 0, (x,y,z), ds;
     92    ideal I = jacob(x5+y6+z7+xyz);
     93    ideal J = modStd(I, 0);
     94    J;
     95
     96    ring R3 = 0, x(1..4), lp;
     97    ideal I = cyclic(4);
     98    ideal J1 = modStd(I, 1);   // default
     99    ideal J2 = modStd(I, 0);
     100    size(reduce(J1, J2));
     101    size(reduce(J2, J1));
     102}
     103
     104/* compute a normalized GB via groebner() */
     105static proc groebner_norm(ideal I)
     106{
     107    I = simplify(groebner(I), 1);
     108    attrib(I, "isSB", 1);
     109    return(I);
     110}
     111
     112/* test if the prime p is suitable for the input, i.e. it does not divide
     113 * the numerator or denominator of any of the coefficients */
     114static proc primeTest_std(int p, alias list args)
     115{
     116    /* erase zero generators */
     117    ideal I = simplify(args[1], 2);
     118
     119    /* clear denominators and count the terms */
     120    ideal J;
     121    ideal K;
     122    int n = ncols(I);
     123    intvec sizes;
     124    number cnt;
     125    int i;
     126    for(i = n; i > 0; i--) {
     127        J[i] = cleardenom(I[i]);
     128        cnt = leadcoef(J[i])/leadcoef(I[i]);
     129        K[i] = numerator(cnt)*var(1)+denominator(cnt);
     130    }
     131    sizes = size(J[1..n]);
     132
     133    /* change to characteristic p */
     134    def br = basering;
     135    list lbr = ringlist(br);
     136    if (typeof(lbr[1]) == "int") {
     137        lbr[1] = p;
     138    }
     139    else {
     140        lbr[1][1] = p;
     141    }
     142    def rp = ring(lbr);
     143    setring(rp);
     144    ideal Jp = fetch(br, J);
     145    ideal Kp = fetch(br, K);
     146
     147    /* test if any coefficient is missing */
     148    if (intvec(size(Kp[1..n])) != 2:n) {
     149        setring(br);
     150        return(0);
     151    }
     152    if (intvec(size(Jp[1..n])) != sizes) {
     153        setring(br);
     154        return(0);
     155    }
     156    setring(br);
     157    return(1);
     158}
     159
     160/* find entries in modresults which come from unlucky primes.
     161 * For this, sort the entries into categories depending on their leading
     162 * ideal and return the indices in all but the biggest category. */
     163static proc deleteUnluckyPrimes_std(alias list modresults)
     164{
     165    int size_modresults = size(modresults);
     166
     167    /* sort results into categories.
     168     * each category is represented by three entries:
     169     * - the corresponding leading ideal
     170     * - the number of elements
     171     * - the indices of the elements
     172     */
     173    list cat;
     174    int size_cat;
     175    ideal L;
     176    int i;
     177    int j;
     178    for (i = 1; i <= size_modresults; i++) {
     179        L = lead(modresults[i]);
     180        attrib(L, "isSB", 1);
     181        for (j = 1; j <= size_cat; j++) {
     182            if (size(L) == size(cat[j][1])
     183                && size(reduce(L, cat[j][1])) == 0
     184                && size(reduce(cat[j][1], L)) == 0) {
     185                cat[j][2] = cat[j][2]+1;
     186                cat[j][3][cat[j][2]] = i;
     187                break;
     188            }
     189        }
     190        if (j > size_cat) {
     191            size_cat++;
     192            cat[size_cat] = list();
     193            cat[size_cat][1] = L;
     194            cat[size_cat][2] = 1;
     195            cat[size_cat][3] = list(i);
     196        }
     197    }
     198
     199    /* find the biggest categories */
     200    int cat_max = 1;
     201    int max = cat[1][2];
     202    for (i = 2; i <= size_cat; i++) {
     203        if (cat[i][2] > max) {
     204            cat_max = i;
     205            max = cat[i][2];
     206        }
     207    }
     208
     209    /* return all other indices */
     210    list unluckyIndices;
     211    for (i = 1; i <= size_cat; i++) {
     212        if (i != cat_max) {
     213            unluckyIndices = unluckyIndices + cat[i][3];
     214        }
     215    }
     216    return(unluckyIndices);
     217}
     218
     219/* test if 'command' applied to 'args' in characteristic p is the same as
     220   'result' mapped to characteristic p */
     221static proc pTest_std(string command, list args, ideal result, int p)
     222{
     223    /* change to characteristic p */
     224    def br = basering;
     225    list lbr = ringlist(br);
     226    if (typeof(lbr[1]) == "int") {
     227        lbr[1] = p;
     228    }
     229    else {
     230        lbr[1][1] = p;
     231    }
     232    def rp = ring(lbr);
     233    setring(rp);
     234    ideal Ip = fetch(br, args)[1];
     235    ideal Gp = fetch(br, result);
     236    attrib(Gp, "isSB", 1);
     237
     238    /* test if Ip is in Gp */
     239    int i;
     240    for (i = ncols(Ip); i > 0; i--) {
     241        if (reduce(Ip[i], Gp, 1) != 0) {
     242            setring(br);
     243            return(0);
     244        }
     245    }
     246
     247    /* compute command(args) */
     248    execute("Ip = "+command+"(Ip);");
     249
     250    /* test if Gp is in Ip */
     251    for (i = ncols(Gp); i > 0; i--) {
     252        if (reduce(Gp[i], Ip, 1) != 0) {
     253            setring(br);
     254            return(0);
     255        }
     256    }
     257    setring(br);
     258    return(1);
     259}
     260
     261/* test if 'result' is a GB of the input ideal */
     262static proc finalTest_std(string command, alias list args, ideal result)
     263{
     264    /* test if args[1] is in result */
     265    attrib(result, "isSB", 1);
     266    int i;
     267    for (i = ncols(args[1]); i > 0; i--) {
     268        if (reduce(args[1][i], result, 1) != 0) {
     269            return(0);
     270        }
     271    }
     272
     273    /* test if result is a GB */
     274    ideal G = std(result);
     275    if (reduce_parallel(G, result)) {
     276        return(0);
     277    }
     278    return(1);
     279}
     280
     281/* return 1, if I_reduce is _not_ in G_reduce,
     282 *        0, otherwise
     283 * (same as size(reduce(I_reduce, G_reduce))).
     284 * Uses parallelization. */
     285static proc reduce_parallel(ideal I_reduce, ideal G_reduce)
     286{
     287    exportto(Modstd, I_reduce);
     288    exportto(Modstd, G_reduce);
     289    int size_I = ncols(I_reduce);
     290    int chunks = Modular::par_range(size_I);
     291    intvec range;
     292    int i;
     293    for (i = chunks; i > 0; i--) {
     294        range = Modular::par_range(size_I, i);
     295        task t(i) = "Modstd::reduce_task", list(range);
     296    }
     297    startTasks(t(1..chunks));
     298    waitAllTasks(t(1..chunks));
     299    int result = 0;
     300    for (i = chunks; i > 0; i--) {
     301        if (getResult(t(i))) {
     302            result = 1;
     303            break;
     304        }
     305    }
     306    kill I_reduce;
     307    kill G_reduce;
     308    return(result);
     309}
     310
     311/* compute a chunk of reductions for reduce_parallel */
     312static proc reduce_task(intvec range)
     313{
     314    int result = 0;
     315    int i;
     316    for (i = range[1]; i <= range[2]; i++) {
     317        if (reduce(I_reduce[i], G_reduce, 1) != 0) {
     318            result = 1;
     319            break;
     320        }
     321    }
     322    return(result);
     323}
     324
     325////////////////////////////////////////////////////////////////////////////////
     326/*
     327 * The following procedures are kept for backward compatibility with the old
     328 * version of modstd.lib. As of now (May 2014), they are still needed in
     329 * assprimeszerodim.lib, modnormal.lib, modwalk.lib, and symodstd.lib. They can
     330 * be removed here as soon as they are not longer needed in these libraries.
     331 */
     332
    29333LIB "parallel.lib";
    30334
    31 ////////////////////////////////////////////////////////////////////////////////
    32 
    33335static proc mod_init()
    34336{
    35337   newstruct("idealPrimeTest", "ideal Ideal");
    36338}
    37 
    38 ////////////////////////////////////////////////////////////////////////////////
    39339
    40340static proc redFork(ideal I, ideal J, int n)
     
    43343   return(reduce(I,J,1));
    44344}
    45 
    46 ////////////////////////////////////////////////////////////////////////////////
    47345
    48346proc isIncluded(ideal I, ideal J, list #)
     
    149447}
    150448
    151 ////////////////////////////////////////////////////////////////////////////////
    152 
    153 proc pTestSB(ideal I, ideal J, list L, int variant, list #)
    154 "USAGE:  pTestSB(I,J,L,variant,#); I,J ideals, L intvec of primes, variant int
    155 RETURN:  1 (resp. 0) if for a randomly chosen prime p that is not in L
    156          J mod p is (resp. is not) a standard basis of I mod p
    157 EXAMPLE: example pTestSB; shows an example
    158 "
    159 {
    160    int i,j,k,p;
    161    def R = basering;
    162    list r = ringlist(R);
    163 
    164    while(!j)
    165    {
    166       j = 1;
    167       p = prime(random(1000000000,2134567879));
    168       for(i = 1; i <= size(L); i++)
    169       {
    170          if(p == L[i]) { j = 0; break; }
    171       }
    172       if(j)
    173       {
    174          for(i = 1; i <= ncols(I); i++)
    175          {
    176             for(k = 2; k <= size(I[i]); k++)
    177             {
    178                if((denominator(leadcoef(I[i][k])) mod p) == 0) { j = 0; break; }
    179             }
    180             if(!j){ break; }
    181          }
    182       }
    183       if(j)
    184       {
    185          if(!primeTest(I,p)) { j = 0; }
    186       }
    187    }
    188    r[1] = p;
    189    def @R = ring(r);
    190    setring @R;
    191    ideal I = imap(R,I);
    192    ideal J = imap(R,J);
    193    attrib(J,"isSB",1);
    194 
    195    int t = timer;
    196    j = 1;
    197    if(isIncluded(I,J) == 0) { j = 0; }
    198 
    199    if(printlevel >= 11)
    200    {
    201       "isIncluded(I,J) takes "+string(timer - t)+" seconds";
    202       "j = "+string(j);
    203    }
    204 
    205    t = timer;
    206    if(j)
    207    {
    208       if(size(#) > 0)
    209       {
    210          ideal K = modpStd(I,p,variant,#[1])[1];
    211       }
    212       else
    213       {
    214          ideal K = groebner(I);
    215       }
    216       t = timer;
    217       if(isIncluded(J,K) == 0) { j = 0; }
    218 
    219       if(printlevel >= 11)
    220       {
    221          "isIncluded(J,K) takes "+string(timer - t)+" seconds";
    222          "j = "+string(j);
    223       }
    224    }
    225    setring R;
    226    return(j);
    227 }
    228 example
    229 { "EXAMPLE:"; echo = 2;
    230    intvec L = 2,3,5;
    231    ring r = 0,(x,y,z),dp;
    232    ideal I = x+1,x+y+1;
    233    ideal J = x+1,y;
    234    pTestSB(I,I,L,2);
    235    pTestSB(I,J,L,2);
    236 }
    237 
    238 ////////////////////////////////////////////////////////////////////////////////
    239 
    240449proc deleteUnluckyPrimes(list T, list L, int ho, list #)
    241450"USAGE:  deleteUnluckyPrimes(T,L,ho,#); T/L list of polys/primes, ho integer
     
    347556}
    348557
    349 ////////////////////////////////////////////////////////////////////////////////
    350 
    351558proc primeTest(def II, bigint p)
    352559{
     
    379586   return(1);
    380587}
    381 
    382 ////////////////////////////////////////////////////////////////////////////////
    383588
    384589proc primeList(ideal I, int n, list #)
     
    498703}
    499704
    500 ////////////////////////////////////////////////////////////////////////////////
    501 
    502 static proc liftstd1(ideal I)
    503 {
    504    def R = basering;
    505    list rl = ringlist(R);
    506    list ordl = rl[3];
    507 
    508    int i;
    509    for(i = 1; i <= size(ordl); i++)
    510    {
    511       if((ordl[i][1] == "C") || (ordl[i][1] == "c"))
    512       {
    513          ordl = delete(ordl, i);
    514          break;
    515       }
    516    }
    517 
    518    ordl = insert(ordl, list("c", 0));
    519    rl[3] = ordl;
    520    def newR = ring(rl);
    521    setring newR;
    522    ideal I = imap(R,I);
    523 
    524    intvec opt = option(get);
    525    option(none);
    526    option(prompt);
    527 
    528    module M;
    529    for(i = 1; i <= size(I); i++)
    530    {
    531       M = M + module(I[i]*gen(1) + gen(i+1));
    532       M = M + module(gen(i+1));
    533    }
    534 
    535    module sM = std(M);
    536 
    537    ideal sI;
    538    if(attrib(R,"global"))
    539    {
    540       for(i = size(I)+1; i <= size(sM); i++)
    541       {
    542          sI[size(sI)+1] = sM[i][1];
    543       }
    544       matrix T = submat(sM,2..nrows(sM),size(I)+1..ncols(sM));
    545    }
    546    else
    547    {
    548       //"==========================================================";
    549       //"WARNING: Algorithm is not applicable if ordering is mixed.";
    550       //"==========================================================";
    551       for(i = 1; i <= size(sM)-size(I); i++)
    552       {
    553          sI[size(sI)+1] = sM[i][1];
    554       }
    555       matrix T = submat(sM,2..nrows(sM),1..ncols(sM)-size(I));
    556    }
    557 
    558    setring R;
    559    option(set, opt);
    560    return(imap(newR,sI),imap(newR,T));
    561 }
    562 example
    563 { "EXAMPLE:"; echo = 2;
    564    ring R = 0,(x,y,z),dp;
    565    poly f = x3+y7+z2+xyz;
    566    ideal i = jacob(f);
    567    matrix T;
    568    ideal sm = liftstd(i,T);
    569    sm;
    570    print(T);
    571    matrix(sm) - matrix(i)*T;
    572 
    573 
    574    ring S = 32003, x(1..5), lp;
    575    ideal I = cyclic(5);
    576    ideal sI;
    577    matrix T;
    578    sI,T = liftstd1(I);
    579    matrix(sI) - matrix(I)*T;
    580 }
    581 
    582 ////////////////////////////////////////////////////////////////////////////////
    583 
    584 proc modpStd(ideal I, int p, int variant, list #)
    585 "USAGE:  modpStd(I,p,variant,#); I ideal, p integer, variant integer
    586 ASSUME:  If size(#) > 0, then #[1] is an intvec describing the Hilbert series.
    587 RETURN:  ideal - a standard basis of I mod p, integer - p
    588 NOTE:    The procedure computes a standard basis of the ideal I modulo p and
    589          fetches the result to the basering. If size(#) > 0 the Hilbert driven
    590          standard basis computation std(.,#[1]) is used instead of groebner.
    591          The standard basis computation modulo p does also vary depending on the
    592          integer variant, namely
    593 @*       - variant = 1: std(.,#[1]) resp. groebner,
    594 @*       - variant = 2: groebner,
    595 @*       - variant = 3: homog. - std(.,#[1]) resp. groebner - dehomog.,
    596 @*       - variant = 4: fglm.
    597 EXAMPLE: example modpStd; shows an example
    598 "
    599 {
    600    def R0 = basering;
    601    list rl = ringlist(R0);
    602    rl[1] = p;
    603    def @r = ring(rl);
    604    setring @r;
    605    ideal i = fetch(R0,I);
    606 
    607    option(redSB);
    608 
    609    if(variant == 1)
    610    {
    611       if(size(#) > 0)
    612       {
    613          i = std(i, #[1]);
    614       }
    615       else
    616       {
    617          i = groebner(i);
    618       }
    619    }
    620 
    621    if(variant == 2)
    622    {
    623       i = groebner(i);
    624    }
    625 
    626    if(variant == 3)
    627    {
    628       list rl = ringlist(@r);
    629       int nvar@r = nvars(@r);
    630 
    631       int k;
    632       intvec w;
    633       for(k = 1; k <= nvar@r; k++)
    634       {
    635          w[k] = deg(var(k));
    636       }
    637       w[nvar@r + 1] = 1;
    638 
    639       rl[2][nvar@r + 1] = "homvar";
    640       rl[3][2][2] = w;
    641 
    642       def HomR = ring(rl);
    643       setring HomR;
    644       ideal i = imap(@r, i);
    645       i = homog(i, homvar);
    646 
    647       if(size(#) > 0)
    648       {
    649          if(w == 1)
    650          {
    651             i = std(i, #[1]);
    652          }
    653          else
    654          {
    655             i = std(i, #[1], w);
    656          }
    657       }
    658       else
    659       {
    660          i = groebner(i);
    661       }
    662 
    663       i = subst(i, homvar, 1);
    664       i = simplify(i, 34);
    665 
    666       setring @r;
    667       i = imap(HomR, i);
    668       i = interred(i);
    669       kill HomR;
    670    }
    671 
    672    if(variant == 4)
    673    {
    674       def R1 = changeord(list(list("dp",1:nvars(basering))));
    675       setring R1;
    676       ideal i = fetch(@r,i);
    677       i = std(i);
    678       setring @r;
    679       i = fglm(R1,i);
    680    }
    681 
    682    setring R0;
    683    return(list(fetch(@r,i),p));
    684 }
    685 example
    686 { "EXAMPLE:"; echo = 2;
    687    ring r = 0, x(1..4), dp;
    688    ideal I = cyclic(4);
    689    int p = 181;
    690    list P = modpStd(I,p,2);
    691    P;
    692 
    693    ring r2 = 0, x(1..5), lp;
    694    ideal I = cyclic(5);
    695    int q = 32003;
    696    list Q = modpStd(I,q,4);
    697    Q;
    698 }
    699 
    700 static proc algeModStd(ideal i,list #)
    701 {
    702 //reduces modStd over algebraic extensions to the one over a polynomial ring
    703    list L=#;
    704    def R=basering;
    705    int n=nvars(R);
    706    list rl=ringlist(R);
    707    poly p=minpoly;
    708    rl[2][n+1]=rl[1][2][1];
    709    rl[1]=rl[1][1];
    710    rl[3][size(rl[3])+1]=rl[3][size(rl[3])];
    711    rl[3][size(rl[3])-1]=list("dp",1);
    712    def S=ring(rl);
    713    setring S;
    714    poly p=imap(R,p);
    715    ideal i=imap(R,i);
    716    i=i,p;
    717    ideal j=modStd(i,L);
    718    if(j[1]==p)
    719    {
    720       j[1]=0;
    721    }
    722    j=simplify(j,2);
    723    setring R;
    724    ideal j=imap(S,j);
    725    return(j);
    726 }
    727 ////////////////////////////// main procedures /////////////////////////////////
    728 
    729 proc modStd(ideal I, list #)
    730 "USAGE:  modStd(I); I ideal
    731 ASSUME:  If size(#) > 0, then # contains either 1, 2 or 4 integers such that
    732 @*       - #[1] is the number of available processors for the computation,
    733 @*       - #[2] is an optional parameter for the exactness of the computation,
    734                 if #[2] = 1, the procedure computes a standard basis for sure,
    735 @*       - #[3] is the number of primes until the first lifting,
    736 @*       - #[4] is the constant number of primes between two liftings until
    737            the computation stops.
    738 RETURN:  a standard basis of I if no warning appears;
    739 NOTE:    The procedure computes a standard basis of I (over the rational
    740          numbers) by using modular methods.
    741          By default the procedure computes a standard basis of I for sure, but
    742          if the optional parameter #[2] = 0, it computes a standard basis of I
    743          with high probability.
    744          The procedure distinguishes between different variants for the standard
    745          basis computation in positive characteristic depending on the ordering
    746          of the basering, the parameter #[2] and if the ideal I is homogeneous.
    747 @*       - variant = 1, if I is homogeneous,
    748 @*       - variant = 2, if I is not homogeneous, 1-block-ordering,
    749 @*       - variant = 3, if I is not homogeneous, complicated ordering (lp or
    750                         > 1 block),
    751 @*       - variant = 4, if I is not homogeneous, ordering lp, dim(I) = 0.
    752 EXAMPLE: example modStd; shows an example
    753 "
    754 {
    755    int TT = timer;
    756    int RT = rtimer;
    757 
    758    def R0 = basering;
    759    list rl = ringlist(R0);
    760 
    761    int algebraic;
    762    if(size(#)>0)
    763    {
    764       if(#[1]<=0)
    765       {
    766          algebraic=1;
    767          #[1]=-#[1];
    768          if(#[1]==0){list LK;#=LK;}
    769       }
    770    }
    771 
    772    if((npars(R0) > 0) || (rl[1][1] > 0))
    773    {
    774       if(npars(R0)==1)
    775       {
    776          if(minpoly!=0)
    777          {
    778             list LM=#;
    779             if(size(LM)==0){LM[1]=0;}
    780             LM[1]=-LM[1];
    781             return(algeModStd(I,LM));
    782          }
    783       }
    784 
    785       ERROR("Characteristic of basering should be zero, basering should
    786              have no parameters.");
    787    }
    788 
    789    int index = 1;
    790    int i,k,c;
    791    int j = 1;
    792    int pTest, sizeTest;
    793    int en = 2134567879;
    794    int an = 1000000000;
    795    bigint N;
    796 
    797 //--------------------  Initialize optional parameters  ------------------------
    798    if(size(#) > 0)
    799    {
    800       if(size(#) == 1)
    801       {
    802          int n1 = #[1];
    803          int exactness = 1;
    804          if(n1 >= 10)
    805          {
    806             int n2 = n1 + 1;
    807             int n3 = n1;
    808          }
    809          else
    810          {
    811             int n2 = 10;
    812             int n3 = 10;
    813          }
    814       }
    815       if(size(#) == 2)
    816       {
    817          int n1 = #[1];
    818          int exactness = #[2];
    819          if(n1 >= 10)
    820          {
    821             int n2 = n1 + 1;
    822             int n3 = n1;
    823          }
    824          else
    825          {
    826             int n2 = 10;
    827             int n3 = 10;
    828          }
    829       }
    830       if(size(#) == 4)
    831       {
    832          int n1 = #[1];
    833          int exactness = #[2];
    834          if(n1 >= #[3])
    835          {
    836             int n2 = n1 + 1;
    837          }
    838          else
    839          {
    840             int n2 = #[3];
    841          }
    842          if(n1 >= #[4])
    843          {
    844             int n3 = n1;
    845          }
    846          else
    847          {
    848             int n3 = #[4];
    849          }
    850       }
    851    }
    852    else
    853    {
    854       int n1 = 1;
    855       int exactness = 1;
    856       int n2 = 10;
    857       int n3 = 10;
    858    }
    859 
    860    if(printlevel >= 10)
    861    {
    862       "n1 = "+string(n1)+", n2 = "+string(n2)+", n3 = "+string(n3)
    863        +", exactness = "+string(exactness);
    864    }
    865 
    866 //-------------------------  Save current options  -----------------------------
    867    intvec opt = option(get);
    868 
    869    option(redSB);
    870 
    871 //--------------------  Initialize the list of primes  -------------------------
    872    int tt = timer;
    873    int rt = rtimer;
    874    intvec L = primeList(I,n2,n1);
    875    if(printlevel >= 10)
    876    {
    877       "CPU-time for primeList: "+string(timer-tt)+" seconds.";
    878       "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
    879    }
    880    L[5] = prime(random(an,en));
    881 
    882 //---------------------  Decide which variant to take  -------------------------
    883    int variant;
    884    int h = homog(I);
    885 
    886    tt = timer;
    887    rt = rtimer;
    888 
    889    if(!hasMixedOrdering())
    890    {
    891       if(h)
    892       {
    893          variant = 1;
    894          if(printlevel >= 10) { "variant = 1"; }
    895 
    896          rl[1] = L[5];
    897          def @r = ring(rl);
    898          setring @r;
    899          def @s = changeord(list(list("dp",1:nvars(basering))));
    900          setring @s;
    901          ideal I = std(fetch(R0,I));
    902          intvec hi = hilb(I,1);
    903          setring R0;
    904          kill @r,@s;
    905       }
    906       else
    907       {
    908          string ordstr_R0 = ordstr(R0);
    909          int neg = 1 - attrib(R0,"global");
    910 
    911          if((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg)
    912          {
    913             variant = 2;
    914             if(printlevel >= 10) { "variant = 2"; }
    915          }
    916          else
    917          {
    918             string order;
    919             if(system("nblocks") <= 2)
    920             {
    921                if(find(ordstr_R0, "M") + find(ordstr_R0, "lp")
    922                                        + find(ordstr_R0, "rp") <= 0)
    923                {
    924                   order = "simple";
    925                }
    926             }
    927 
    928             if((order == "simple") || (size(rl) > 4))
    929             {
    930                variant = 2;
    931                if(printlevel >= 10) { "variant = 2"; }
    932             }
    933             else
    934             {
    935                rl[1] = L[5];
    936                def @r = ring(rl);
    937                setring @r;
    938 
    939                def @s = changeord(list(list("dp",1:nvars(basering))));
    940                setring @s;
    941                ideal I = std(fetch(R0,I));
    942                if(dim(I) == 0)
    943                {
    944                   variant = 4;
    945                   if(printlevel >= 10) { "variant = 4"; }
    946                }
    947                else
    948                {
    949                   variant = 3;
    950                   if(printlevel >= 10) { "variant = 3"; }
    951 
    952                   int nvar@r = nvars(@r);
    953                   intvec w;
    954                   for(i = 1; i <= nvar@r; i++)
    955                   {
    956                      w[i] = deg(var(i));
    957                   }
    958                   w[nvar@r + 1] = 1;
    959 
    960                   list hiRi = hilbRing(fetch(R0,I),w);
    961                   intvec W = hiRi[2];
    962                   @s = hiRi[1];
    963                   setring @s;
    964 
    965                   Id(1) = std(Id(1));
    966                   intvec hi = hilb(Id(1), 1, W);
    967                }
    968 
    969                setring R0;
    970                kill @r,@s;
    971             }
    972          }
    973       }
    974    }
    975    else
    976    {
    977       if(exactness == 1) { return(groebner(I)); }
    978       if(h)
    979       {
    980          variant = 1;
    981          if(printlevel >= 10) { "variant = 1"; }
    982          rl[1] = L[5];
    983          def @r = ring(rl);
    984          setring @r;
    985          def @s = changeord(list(list("dp",1:nvars(basering))));
    986          setring @s;
    987          ideal I = std(fetch(R0,I));
    988          intvec hi = hilb(I,1);
    989          setring R0;
    990          kill @r,@s;
    991       }
    992       else
    993       {
    994          string ordstr_R0 = ordstr(R0);
    995          int neg = 1 - attrib(R0,"global");
    996 
    997          if((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg)
    998          {
    999             variant = 2;
    1000             if(printlevel >= 10) { "variant = 2"; }
    1001          }
    1002          else
    1003          {
    1004             string order;
    1005             if(system("nblocks") <= 2)
    1006             {
    1007                if(find(ordstr_R0, "M") + find(ordstr_R0, "lp")
    1008                                        + find(ordstr_R0, "rp") <= 0)
    1009                {
    1010                   order = "simple";
    1011                }
    1012             }
    1013 
    1014             if((order == "simple") || (size(rl) > 4))
    1015             {
    1016                variant = 2;
    1017                if(printlevel >= 10) { "variant = 2"; }
    1018             }
    1019             else
    1020             {
    1021                variant = 3;
    1022                if(printlevel >= 10) { "variant = 3"; }
    1023 
    1024                rl[1] = L[5];
    1025                def @r = ring(rl);
    1026                setring @r;
    1027                int nvar@r = nvars(@r);
    1028                intvec w;
    1029                for(i = 1; i <= nvar@r; i++)
    1030                {
    1031                   w[i] = deg(var(i));
    1032                }
    1033                w[nvar@r + 1] = 1;
    1034 
    1035                list hiRi = hilbRing(fetch(R0,I),w);
    1036                intvec W = hiRi[2];
    1037                def @s = hiRi[1];
    1038                setring @s;
    1039 
    1040                Id(1) = std(Id(1));
    1041                intvec hi = hilb(Id(1), 1, W);
    1042 
    1043                setring R0;
    1044                kill @r,@s;
    1045             }
    1046          }
    1047       }
    1048    }
    1049    if(algebraic){variant=2;}
    1050 
    1051    list P,T1,T2,T3,LL;
    1052 
    1053    ideal J,K,H;
    1054 
    1055 //-----  If there is more than one processor available, we parallelize the  ----
    1056 //-----  main standard basis computations in positive characteristic        ----
    1057 
    1058    if(n1 > 1)
    1059    {
    1060       ideal I_for_fork = I;
    1061       export(I_for_fork);           // I available for each link
    1062 
    1063 //-----  Create n1 links l(1),...,l(n1), open all of them and compute  ---------
    1064 //-----  standard basis for the primes L[2],...,L[n1 + 1].             ---------
    1065 
    1066       for(i = 1; i <= n1; i++)
    1067       {
    1068          //link l(i) = "MPtcp:fork";
    1069          link l(i) = "ssi:fork";
    1070          open(l(i));
    1071          if((variant == 1) || (variant == 3))
    1072          {
    1073             write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
    1074                                                   eval(variant), eval(hi))));
    1075          }
    1076          if((variant == 2) || (variant == 4))
    1077          {
    1078             write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
    1079                                                   eval(variant))));
    1080          }
    1081       }
    1082 
    1083       int t = timer;
    1084       if((variant == 1) || (variant == 3))
    1085       {
    1086          P = modpStd(I_for_fork, L[1], variant, hi);
    1087       }
    1088       if((variant == 2) || (variant == 4))
    1089       {
    1090          P = modpStd(I_for_fork, L[1], variant);
    1091       }
    1092       t = timer - t;
    1093       if(t > 60) { t = 60; }
    1094       int i_sleep = system("sh", "sleep "+string(t));
    1095       T1[1] = P[1];
    1096       T2[1] = bigint(P[2]);
    1097       index++;
    1098 
    1099       j = j + n1 + 1;
    1100    }
    1101 
    1102 //--------------  Main standard basis computations in positive  ----------------
    1103 //----------------------  characteristic start here  ---------------------------
    1104 
    1105    list arguments_farey, results_farey;
    1106 
    1107    while(1)
    1108    {
    1109       tt = timer; rt = rtimer;
    1110 
    1111       if(printlevel >= 10) { "size(L) = "+string(size(L)); }
    1112 
    1113       if(n1 > 1)
    1114       {
    1115          while(j <= size(L) + 1)
    1116          {
    1117             for(i = 1; i <= n1; i++)
    1118             {
    1119                //--- ask if link l(i) is ready otherwise sleep for t seconds ---
    1120                if(status(l(i), "read", "ready"))
    1121                {
    1122                   //--- read the result from l(i) ---
    1123                   P = read(l(i));
    1124                   T1[index] = P[1];
    1125                   T2[index] = bigint(P[2]);
    1126                   index++;
    1127 
    1128                   if(j <= size(L))
    1129                   {
    1130                      if((variant == 1) || (variant == 3))
    1131                      {
    1132                         write(l(i), quote(modpStd(I_for_fork, eval(L[j]),
    1133                                                   eval(variant), eval(hi))));
    1134                         j++;
    1135                      }
    1136                      if((variant == 2) || (variant == 4))
    1137                      {
    1138                         write(l(i), quote(modpStd(I_for_fork,
    1139                                                   eval(L[j]), eval(variant))));
    1140                         j++;
    1141                      }
    1142                   }
    1143                   else
    1144                   {
    1145                      k++;
    1146                      close(l(i));
    1147                   }
    1148                }
    1149             }
    1150             //--- k describes the number of closed links ---
    1151             if(k == n1)
    1152             {
    1153                j++;
    1154             }
    1155             i_sleep = system("sh", "sleep "+string(t));
    1156          }
    1157       }
    1158       else
    1159       {
    1160          while(j <= size(L))
    1161          {
    1162             if((variant == 1) || (variant == 3))
    1163             {
    1164                P = modpStd(I, L[j], variant, hi);
    1165             }
    1166             if((variant == 2) || (variant == 4))
    1167             {
    1168                P = modpStd(I, L[j], variant);
    1169             }
    1170 
    1171             T1[index] = P[1];
    1172             T2[index] = bigint(P[2]);
    1173             index++;
    1174             j++;
    1175          }
    1176       }
    1177 
    1178       if(printlevel >= 10)
    1179       {
    1180          "CPU-time for computing list is "+string(timer - tt)+" seconds.";
    1181          "Real-time for computing list is "+string(rtimer - rt)+" seconds.";
    1182       }
    1183 
    1184 //------------------------  Delete unlucky primes  -----------------------------
    1185 //-------------  unlucky if and only if the leading ideal is wrong  ------------
    1186 
    1187       LL = deleteUnluckyPrimes(T1,T2,h);
    1188       T1 = LL[1];
    1189       T2 = LL[2];
    1190 
    1191 //-------------------  Now all leading ideals are the same  --------------------
    1192 //-------------------  Lift results to basering via farey  ---------------------
    1193 
    1194       tt = timer; rt = rtimer;
    1195       N = T2[1];
    1196       for(i = 2; i <= size(T2); i++) { N = N*T2[i]; }
    1197       H = chinrem(T1,T2);
    1198       if(n1 == 1)
    1199       {
    1200          J = farey(H,N);
    1201       }
    1202       else
    1203       {
    1204          for(i = ncols(H); i > 0; i--)
    1205          {
    1206             arguments_farey[i] = list(ideal(H[i]), N);
    1207          }
    1208          results_farey = parallelWaitAll("farey", arguments_farey, 0, n1);
    1209          for(i = ncols(H); i > 0; i--)
    1210          {
    1211             J[i] = results_farey[i][1];
    1212          }
    1213       }
    1214       if(printlevel >= 10)
    1215       {
    1216          "CPU-time for lifting-process is "+string(timer - tt)+" seconds.";
    1217          "Real-time for lifting-process is "+string(rtimer - rt)+" seconds.";
    1218       }
    1219 
    1220 //----------------  Test if we already have a standard basis of I --------------
    1221 
    1222       tt = timer; rt = rtimer;
    1223       if((variant == 1) || (variant == 3))
    1224       {
    1225          pTest = pTestSB(I,J,L,variant,hi);
    1226       }
    1227       if((variant == 2) || (variant == 4))
    1228       {
    1229          pTest = pTestSB(I,J,L,variant);
    1230       }
    1231 
    1232       if(printlevel >= 10)
    1233       {
    1234          "CPU-time for pTest is "+string(timer - tt)+" seconds.";
    1235          "Real-time for pTest is "+string(rtimer - rt)+" seconds.";
    1236       }
    1237 
    1238       if(pTest)
    1239       {
    1240          if(printlevel >= 10)
    1241          {
    1242             "CPU-time for computation without final tests is "
    1243             +string(timer - TT)+" seconds.";
    1244             "Real-time for computation without final tests is "
    1245             +string(rtimer - RT)+" seconds.";
    1246          }
    1247 
    1248          attrib(J,"isSB",1);
    1249 
    1250          if(exactness == 0)
    1251          {
    1252             option(set, opt);
    1253             if(n1 > 1) { kill I_for_fork; }
    1254             return(J);
    1255          }
    1256 
    1257          if(exactness == 1)
    1258          {
    1259             tt = timer; rt = rtimer;
    1260             sizeTest = 1 - isIncluded(I,J,n1);
    1261 
    1262             if(printlevel >= 10)
    1263             {
    1264                "CPU-time for checking if I subset <G> is "
    1265                +string(timer - tt)+" seconds.";
    1266                "Real-time for checking if I subset <G> is "
    1267                +string(rtimer - rt)+" seconds.";
    1268             }
    1269 
    1270             if(sizeTest == 0)
    1271             {
    1272                tt = timer; rt = rtimer;
    1273                K = std(J);
    1274 
    1275                if(printlevel >= 10)
    1276                {
    1277                   "CPU-time for last std-computation is "
    1278                   +string(timer - tt)+" seconds.";
    1279                   "Real-time for last std-computation is "
    1280                   +string(rtimer - rt)+" seconds.";
    1281                }
    1282 
    1283                if(size(reduce(K,J)) == 0)
    1284                {
    1285                   option(set, opt);
    1286                   if(n1 > 1) { kill I_for_fork; }
    1287                   return(J);
    1288                }
    1289             }
    1290          }
    1291       }
    1292 
    1293 //--------------  We do not already have a standard basis of I  ----------------
    1294 //-----------  Therefore do the main computation for more primes  --------------
    1295 
    1296       T1 = H;
    1297       T2 = N;
    1298       index = 2;
    1299 
    1300       j = size(L) + 1;
    1301       tt = timer; rt = rtimer;
    1302       L = primeList(I,n3,L,n1);
    1303       if(printlevel >= 10)
    1304       {
    1305          "CPU-time for primeList: "+string(timer-tt)+" seconds.";
    1306          "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
    1307       }
    1308 
    1309       if(n1 > 1)
    1310       {
    1311          for(i = 1; i <= n1; i++)
    1312          {
    1313             open(l(i));
    1314             if((variant == 1) || (variant == 3))
    1315             {
    1316                write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
    1317                                                      eval(variant), eval(hi))));
    1318             }
    1319             if((variant == 2) || (variant == 4))
    1320             {
    1321                write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
    1322                                                      eval(variant))));
    1323             }
    1324          }
    1325          j = j + n1;
    1326          k = 0;
    1327       }
    1328    }
    1329 }
    1330 example
    1331 { "EXAMPLE:"; echo = 2;
    1332    ring R1 = 0,(x,y,z,t),dp;
    1333    ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
    1334    ideal J = modStd(I);
    1335    J;
    1336    I = homog(I,t);
    1337    J = modStd(I);
    1338    J;
    1339 
    1340    ring R2 = 0,(x,y,z),ds;
    1341    ideal I = jacob(x5+y6+z7+xyz);
    1342    ideal J1 = modStd(I,1,0);
    1343    J1;
    1344 
    1345    ring R3 = 0,x(1..4),lp;
    1346    ideal I = cyclic(4);
    1347    ideal J1 = modStd(I,1);
    1348    ideal J2 = modStd(I,1,0);
    1349    size(reduce(J1,J2));
    1350    size(reduce(J2,J1));
    1351 }
    1352 
    1353 ////////////////////////////////////////////////////////////////////////////////
    1354 
    1355 proc modS(ideal I, list L, list #)
    1356 "USAGE:  modS(I,L); I ideal, L intvec of primes
    1357          if size(#)>0 std is used instead of groebner
    1358 RETURN:  an ideal which is with high probability a standard basis
    1359 NOTE:    This procedure is designed for fast experiments.
    1360          It is not tested whether the result is a standard basis.
    1361          It is not tested whether the result generates I.
    1362 EXAMPLE: example modS; shows an example
    1363 "
    1364 {
    1365    int j;
    1366    bigint N = 1;
    1367    def R0 = basering;
    1368    ideal J;
    1369    list T;
    1370    list rl = ringlist(R0);
    1371    if((npars(R0)>0) || (rl[1]>0))
    1372    {
    1373       ERROR("Characteristic of basering should be zero.");
    1374    }
    1375    for(j = 1; j <= size(L); j++)
    1376    {
    1377       N = N*L[j];
    1378       rl[1] = L[j];
    1379       def @r = ring(rl);
    1380       setring @r;
    1381       ideal I = fetch(R0,I);
    1382       if(size(#) > 0)
    1383       {
    1384          I = std(I);
    1385       }
    1386       else
    1387       {
    1388          I = groebner(I);
    1389       }
    1390       setring R0;
    1391       T[j] = fetch(@r,I);
    1392       kill @r;
    1393    }
    1394    L = deleteUnluckyPrimes(T,L,homog(I));
    1395    // unlucky if and only if the leading ideal is wrong
    1396    J = farey(chinrem(L[1],L[2]),N);
    1397    attrib(J,"isSB",1);
    1398    return(J);
    1399 }
    1400 example
    1401 { "EXAMPLE:"; echo = 2;
    1402    list L = 3,5,11,13,181,32003;
    1403    ring r = 0,(x,y,z,t),dp;
    1404    ideal I = 3x3+x2+1,11y5+y3+2,5z4+z2+4;
    1405    I = homog(I,t);
    1406    ideal J = modS(I,L);
    1407    J;
    1408 }
    1409 
    1410 ////////////////////////////////////////////////////////////////////////////////
    1411 
    1412 proc modHenselStd(ideal I, list #)
    1413 "USAGE:  modHenselStd(I);
    1414 RETURN:  a standard basis of I;
    1415 NOTE:    The procedure computes a standard basis of I (over the rational
    1416          numbers) by using  modular computations and Hensellifting.
    1417          For further experiments see procedure modS.
    1418 EXAMPLE: example modHenselStd; shows an example
    1419 "
    1420 {
    1421    int i,j;
    1422 
    1423    bigint p = 2134567879;
    1424    if(size(#)!=0) { p=#[1]; }
    1425    while(!primeTest(I,p))
    1426    {
    1427       p = prime(random(2000000000,2134567879));
    1428    }
    1429 
    1430    def R = basering;
    1431    module F,PrevG,PrevZ,Z2;
    1432    ideal testG,testG1,G1,G2,G3,Gp;
    1433    list L = p;
    1434    list rl = ringlist(R);
    1435    rl[1] = int(p);
    1436 
    1437    def S = ring(rl);
    1438    setring S;
    1439    intvec opt = option(get);
    1440    option(redSB);
    1441    module Z,M,Z2;
    1442    ideal I = imap(R,I);
    1443    ideal Gp,G1,G2,G3;
    1444    Gp,Z = liftstd1(I);
    1445    attrib(Gp,"isSB",1);
    1446    module ZZ = syz(I);
    1447    attrib(ZZ,"isSB",1);
    1448    Z = reduce(Z,ZZ);
    1449 
    1450    setring R;
    1451    Gp = imap(S,Gp);
    1452    PrevZ = imap(S,Z);
    1453    PrevG = module(Gp);
    1454    F = module(I);
    1455    testG = farey(Gp,p);
    1456    attrib(testG,"isSB",1);
    1457    while(1)
    1458    {
    1459       i++;
    1460       G1 = ideal(1/(p^i) * sum_id(F*PrevZ,(-1)*PrevG));
    1461       setring S;
    1462       G1 = imap(R,G1);
    1463       G2 = reduce(G1,Gp);
    1464       G3 = sum_id(G1,(-1)*G2);
    1465       M = lift(Gp,G3);
    1466       Z2 = (-1)*Z*M;
    1467 
    1468       setring R;
    1469       G2 = imap(S,G2);
    1470       Z2 = imap(S,Z2);
    1471       PrevG = sum_id(PrevG, module(p^i*G2));
    1472       PrevZ = sum_id(PrevZ, multiply(poly(p^i),Z2));
    1473       testG1 = farey(ideal(PrevG),p^(i+1));
    1474       attrib(testG1,"isSB",1);
    1475       if(size(reduce(testG1,testG)) == 0)
    1476       {
    1477          if(size(reduce(I,testG1)) == 0)       // I is in testG1
    1478          {
    1479             if(pTestSB(I,testG1,L,2))
    1480             {
    1481                G3 = std(testG1);               // testG1 is SB
    1482                if(size(reduce(G3,testG1)) == 0)
    1483                {
    1484                   option(set, opt);
    1485                   return(G3);
    1486                }
    1487             }
    1488          }
    1489       }
    1490       testG = testG1;
    1491       attrib(testG,"isSB",1);
    1492    }
    1493 }
    1494 example
    1495 { "EXAMPLE:"; echo = 2;
    1496    ring r = 0,(x,y,z),dp;
    1497    ideal I = 3x3+x2+1,11y5+y3+2,5z4+z2+4;
    1498    ideal J = modHenselStd(I);
    1499    J;
    1500 }
    1501 
    1502 ////////////////////////////////////////////////////////////////////////////////
    1503 
    1504 static proc sum_id(list #)
    1505 {
    1506    if(typeof(#[1])=="ideal")
    1507    {
    1508       ideal M;
    1509    }
    1510    else
    1511    {
    1512       module M;
    1513    }
    1514 
    1515    int i;
    1516    for(i = 1; i <= ncols(#[1]); i++) { M[i] = #[1][i] + #[2][i]; }
    1517    return(M);
    1518 }
    1519 
    1520 ////////////////////////////////////////////////////////////////////////////////
    1521 
    1522 static proc multiply(poly p, list #)
    1523 {
    1524    if(typeof(#[1])=="ideal")
    1525    {
    1526       ideal M;
    1527    }
    1528    else
    1529    {
    1530       module M;
    1531    }
    1532 
    1533    int i;
    1534    for(i = 1; i <= ncols(#[1]); i++) { M[i] = p * #[1][i]; }
    1535    return(M);
    1536 }
    1537 
    1538 
    1539705////////////////////////////// further examples ////////////////////////////////
    1540706
  • Singular/LIB/modular.lib

    r7063d2 r031e12  
    11////////////////////////////////////////////////////////////////////
    2 version="version modular.lib 3-1-7-0 Dec_2013 ";
     2version="version modular.lib 4.0.0.0 May_2014 "; // $Id$
    33category="General purpose";
    44info="
     
    126126        else {
    127127            ncores_available = system("semaphore", "get_value", sem_cores)+1;
    128             nNewPrimes = nAllPrimes div ncores_available;
    129128            if (nAllPrimes < ncores_available) {
    130129                nNewPrimes = nAllPrimes;
     
    155154        for (i = size(indices); i > 0; i--) {
    156155            modresults = delete(modresults, indices[i]);
     156            primes = delete(primes, indices[i]);
    157157        }
    158158
     
    165165                list(N)+primes);
    166166        }
     167        modresults = list();
    167168        for (i = size(primes); i > 0; i--) {
    168169            N = N*primes[i];
  • Singular/LIB/primdec.lib

    r7063d2 r031e12  
    40064006  }
    40074007  // remaining case: re[n+1] is trivial
    4008   // either n is at least number of variables or 
     4008  // either n is at least number of variables or
    40094009  // resolution happens to be shorter
    40104010  ideal ann=Ann(transpose(re[n]));
     
    41524152  matrix m=char_series(PS);  // We compute an irreducible
    41534153                             // characteristic series
     4154  if ((nrows(m)==1)
     4155  && (ncols(m)==1)
     4156  && (m[1,1]==1)) // in case of an empty series: min_ass_prim_charsets1
     4157  {
     4158    return min_ass_prim_charsets1(PS);
     4159  }
    41544160  int i,j,k;
    41554161  list PSI;
     
    42514257  matrix m=char_series(PS);  // We compute an irreducible
    42524258                             // characteristic series
     4259                             // this series may be empty (1x1: 1)
    42534260  int i,j,k;
     4261  while ((nrows(m)==1)
     4262  && (ncols(m)==1)
     4263  && (m[1,1]==1)) // in case of an empty series: permute the variables
     4264  {
     4265    n=string(var(nvars(oldring)));
     4266    for(i=1;i<nvars(oldring);i++) { n=n+","+string(var(i)); }
     4267    kill r;
     4268    execute("ring r=("+charstr(oldring)+"),("+n+"),dp;");
     4269    ideal PS=imap(oldring,PS);
     4270    matrix m=char_series(PS);
     4271  }
    42544272  ideal I;
    42554273  list PSI;
  • Singular/LIB/primdecint.lib

    ra85671c r031e12  
    1515  polynomial ring over the integers, Z[x_1,...,x_n].
    1616  The first procedure 'primdecZ' can be used in parallel.
     17
     18  Reference: Pfister,   Sadiq, Steidel , \"An Algorithm for primary decomposition in polynomial rings over the integers\" , arXiv:1008.2074
    1719
    1820PROCEDURES:
  • Tst/Long/ok_l.lst

    r7063d2 r031e12  
    3535minor_l
    3636modnormal
     37modstd_l
    3738modulo_l
    3839monodromy_l
  • Tst/Manual.lst

    r7063d2 r031e12  
    10141014Manual/Maxord.tst
    10151015Manual/minpoly.tst
    1016 Manual/modHenselStd.tst
    10171016Manual/module_containment.tst
    10181017Manual/modulo_BR_PLURAL_BR.tst
     
    11451144Manual/minAssGTZ.tst
    11461145Manual/mindist.tst
    1147 Manual/modS.tst
    11481146Manual/multiplylist.tst
    11491147Manual/nonMonomials.tst
  • Tst/Manual/all.lst

    r7063d2 r031e12  
    921921mod2str.tst
    922922modDec.tst
    923 modHenselStd.tst
    924 modS.tst
    925923modStd.tst
    926924mod_versal.tst
  • Tst/Manual/assPrimes.res.gz.uu

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

    r7063d2 r031e12  
    1 1 >> tst_memory_0 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:1480252
    2 1 >> tst_memory_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:1826816
    3 1 >> tst_memory_2 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:2394052
    4 1 >> tst_timer_1 :: 1316104113:3132- exportiert :3-1-3:ix86-Linux:mamawutz:739
     11 >> tst_memory_0 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:1033400
     21 >> tst_memory_1 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2461696
     31 >> tst_memory_2 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2461696
     41 >> tst_timer_1 :: 1400585003:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:1015
  • Tst/Manual/modStd.res.gz.uu

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

    r7063d2 r031e12  
    1 1 >> tst_memory_0 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:269264
    2 1 >> tst_memory_1 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:669168
    3 1 >> tst_memory_2 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:747000
    4 1 >> tst_timer_1 :: 1344354184:3.1.3.sw $Id: 6c9b669 Tue Aug 7 16:53:01 2012 +0200$:spielwiese:version:dilbert:14
     11 >> tst_memory_0 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:395620
     21 >> tst_memory_1 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2322432
     31 >> tst_memory_2 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2408400
     41 >> tst_timer_1 :: 1400569493:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:162
  • Tst/Manual/modStd.tst

    r7063d2 r031e12  
    11LIB "tst.lib"; tst_init();
    22LIB "modstd.lib";
    3 ring R1 = 0,(x,y,z,t),dp;
     3ring R1 = 0, (x,y,z,t), dp;
    44ideal I = 3x3+x2+1, 11y5+y3+2, 5z4+z2+4;
    55ideal J = modStd(I);
    66J;
    7 I = homog(I,t);
     7I = homog(I, t);
    88J = modStd(I);
    99J;
    10 ring R2 = 0,(x,y,z),ds;
     10
     11ring R2 = 0, (x,y,z), ds;
    1112ideal I = jacob(x5+y6+z7+xyz);
    12 ideal J1 = modStd(I,1,0);
    13 J1;
    14 ring R3 = 0,x(1..4),lp;
     13ideal J = modStd(I, 0);
     14J;
     15
     16ring R3 = 0, x(1..4), lp;
    1517ideal I = cyclic(4);
    16 ideal J1 = modStd(I,1);
    17 ideal J2 = modStd(I,1,0);
    18 size(reduce(J1,J2));
    19 size(reduce(J2,J1));
     18ideal J1 = modStd(I, 1);   // default
     19ideal J2 = modStd(I, 0);
     20size(reduce(J1, J2));
     21size(reduce(J2, J1));
    2022tst_status(1);$
  • Tst/Manual/s.lst

    r7063d2 r031e12  
    10261026Maxord.tst
    10271027minpoly.tst
    1028 modHenselStd.tst
    10291028module_containment.tst
    10301029modulo_BR_PLURAL_BR.tst
     
    11571156minAssGTZ.tst
    11581157mindist.tst
    1159 modS.tst
    11601158multiplylist.tst
    11611159nonMonomials.tst
  • Tst/README

    r7063d2 r031e12  
    148148  cd <directopry where xx.tst resides>; perl ../regress.cmd -g xx.tst
    149149
    150 * You can download the newest version of tst.lib from
    151   ftp://www.mathematik.uni-kl.de/pub/Math/Singular/singular-cd/LIBRARIES/tst.lib
    152150
    153 
  • Tst/Rest.lst

    r7063d2 r031e12  
    323323Short/lres_s.tst
    324324Short/minor_s.tst
    325 Short/modstd.tst
     325Short/modstd_s.tst
    326326Short/modulo_s.tst
    327327Short/monodromy_s.tst
  • Tst/Short.lst

    r7063d2 r031e12  
    188188Short/lres_s.tst
    189189Short/minor_s.tst
    190 Short/modstd.tst
     190Short/modstd_s.tst
    191191Short/modulo_s.tst
    192192Short/monodromy_s.tst
     
    260260;MP Short/stratify.tst
    261261Short/string.tst
    262 ;;; Short/symodstd.tst ; the test  is also in Long/
    263262Short/test_c_dp.tst
    264263Short/triang_s.tst
  • Tst/Short/bug_charseries.res.gz.uu

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

    r7063d2 r031e12  
    1 1 >> tst_memory_0 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:236720
    2 1 >> tst_memory_1 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2338816
    3 1 >> tst_memory_2 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:2375480
    4 1 >> tst_timer_1 :: 1399642710:4.0.0, 32 bit:4.0.0:i686-Linux:mamawutz:12
     11 >> tst_memory_0 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:272136
     21 >> tst_memory_1 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2342912
     31 >> tst_memory_2 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:2375984
     41 >> tst_timer_1 :: 1400599075:4.0.0, 64 bit:4.0.0:x86_64-Linux:nepomuck:3
  • Tst/Short/ok_s.lst

    r7063d2 r031e12  
    218218minor_s
    219219modular_s
    220 modstd
     220modstd_s
    221221modulo_s
    222222monodromy_s
  • Tst/regress.lst

    r7063d2 r031e12  
    10341034Manual/Maxord.tst
    10351035Manual/minpoly.tst
    1036 Manual/modHenselStd.tst
    10371036Manual/module_containment.tst
    10381037Manual/modulo_BR_PLURAL_BR.tst
     
    11651164Manual/minAssGTZ.tst
    11661165Manual/mindist.tst
    1167 Manual/modS.tst
    11681166Manual/multiplylist.tst
    11691167Manual/nonMonomials.tst
  • factory/cf_gcd.cc

    r7063d2 r031e12  
    958958content ( const CanonicalForm & f, const Variable & x )
    959959{
     960    if (f.inBaseDomain()) return f;
    960961    ASSERT( x.level() > 0, "cannot calculate content with respect to algebraic variable" );
    961962    Variable y = f.mvar();
Note: See TracChangeset for help on using the changeset viewer.