kstd1.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT:
6 */
7 
8 // TODO: why the following is here instead of mod2.h???
9 
10 
11 // define if buckets should be used
12 #define MORA_USE_BUCKETS
13 
14 #define PRE_INTEGER_CHECK 0
15 
16 #include "kernel/mod2.h"
17 
18 #include "misc/options.h"
19 #include "misc/intvec.h"
20 
21 #include "polys/weight.h"
22 #include "kernel/polys.h"
23 
24 #include "kernel/GBEngine/kutil.h"
25 #include "kernel/GBEngine/kstd1.h"
26 #include "kernel/GBEngine/khstd.h"
28 #include "kernel/ideals.h"
29 
30 //#include "ipprint.h"
31 
32 #ifdef HAVE_PLURAL
33 #include "polys/nc/nc.h"
34 #include "polys/nc/sca.h"
35 #include "kernel/GBEngine/nc.h"
36 #endif
37 
39 
40 
41 /* the list of all options which give a warning by test */
43  |Sy_bit(OPT_REDSB) /* 1 */
44  |Sy_bit(OPT_NOT_SUGAR) /* 3 */
45  |Sy_bit(OPT_INTERRUPT) /* 4 */
46  |Sy_bit(OPT_SUGARCRIT) /* 5 */
49  |Sy_bit(OPT_FASTHC) /* 10 */
50  |Sy_bit(OPT_INTSTRATEGY) /* 26 */
51  |Sy_bit(OPT_INFREDTAIL) /* 28 */
52  |Sy_bit(OPT_NOTREGULARITY) /* 30 */
53  |Sy_bit(OPT_WEIGHTM); /* 31 */
54 
55 /* the list of all options which may be used by option and test */
56 /* defintion of ALL options: libpolys/misc/options.h */
58  |Sy_bit(1)
59  |Sy_bit(2) // obachman 10/00: replaced by notBucket
60  |Sy_bit(3)
61  |Sy_bit(4)
62  |Sy_bit(5)
63  |Sy_bit(6)
64 // |Sy_bit(7) obachman 11/00 tossed: 12/00 used for redThrough
65  |Sy_bit(7) // OPT_REDTHROUGH
66  |Sy_bit(8) // obachman 11/00 tossed -> motsak 2011 experimental: OPT_NO_SYZ_MINIM
67  |Sy_bit(9)
68  |Sy_bit(10)
69  |Sy_bit(11)
70  |Sy_bit(12)
71  |Sy_bit(13)
72  |Sy_bit(14)
73  |Sy_bit(15)
74  |Sy_bit(16)
75  |Sy_bit(17)
76  |Sy_bit(18)
77  |Sy_bit(19)
78 // |Sy_bit(20) obachman 11/00 tossed: 12/00 used for redOldStd
80  |Sy_bit(21)
81  |Sy_bit(22)
82  /*|Sy_bit(23)*/
83  /*|Sy_bit(24)*/
86  |Sy_bit(27)
87  |Sy_bit(28)
88  |Sy_bit(29)
89  |Sy_bit(30)
90  |Sy_bit(31);
91 
92 //static BOOLEAN posInLOldFlag;
93  /*FALSE, if posInL == posInL10*/
94 // returns TRUE if mora should use buckets, false otherwise
95 static BOOLEAN kMoraUseBucket(kStrategy strat);
96 
97 static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
98 {
99 // if (strat->ak == 0 && !rIsSyzIndexRing(currRing))
100  strat->length_pLength = TRUE;
101 // else
102 // strat->length_pLength = FALSE;
103 
104  if ((ldeg == pLDeg0c /*&& !rIsSyzIndexRing(currRing)*/) ||
105  (ldeg == pLDeg0 && strat->ak == 0))
106  {
107  strat->LDegLast = TRUE;
108  }
109  else
110  {
111  strat->LDegLast = FALSE;
112  }
113 }
114 
115 
116 static int doRed (LObject* h, TObject* with,BOOLEAN intoT,kStrategy strat, bool redMoraNF)
117 {
118  int ret;
119 #if KDEBUG > 0
120  kTest_L(h);
121  kTest_T(with);
122 #endif
123  // Hmmm ... why do we do this -- polys from T should already be normalized
125  with->pNorm();
126 #ifdef KDEBUG
127  if (TEST_OPT_DEBUG)
128  {
129  PrintS("reduce ");h->wrp();PrintS(" with ");with->wrp();PrintLn();
130  }
131 #endif
132  if (intoT)
133  {
134  // need to do it exacly like this: otherwise
135  // we might get errors
136  LObject L= *h;
137  L.Copy();
138  h->GetP();
139  h->length=h->pLength=pLength(h->p);
140  ret = ksReducePoly(&L, with, strat->kNoetherTail(), NULL, strat);
141  if (ret)
142  {
143  if (ret < 0) return ret;
144  if (h->tailRing != strat->tailRing)
145  h->ShallowCopyDelete(strat->tailRing,
146  pGetShallowCopyDeleteProc(h->tailRing,
147  strat->tailRing));
148  }
149  if(redMoraNF && (rField_is_Ring(currRing)))
150  enterT_strong(*h,strat);
151  else
152  enterT(*h,strat);
153  *h = L;
154  }
155  else
156  ret = ksReducePoly(h, with, strat->kNoetherTail(), NULL, strat);
157 #ifdef KDEBUG
158  if (TEST_OPT_DEBUG)
159  {
160  PrintS("to ");h->wrp();PrintLn();
161  }
162 #endif
163  return ret;
164 }
165 
167 {
168  int i,at,ei,li,ii;
169  int j = 0;
170  int pass = 0;
171  long d,reddeg;
172 
173  d = h->GetpFDeg()+ h->ecart;
174  reddeg = strat->LazyDegree+d;
175  h->SetShortExpVector();
176  loop
177  {
178  j = kFindDivisibleByInT(strat, h);
179  if (j < 0)
180  {
181  if (strat->honey) h->SetLength(strat->length_pLength);
182  return 1;
183  }
184 
185  ei = strat->T[j].ecart;
186  ii = j;
187 
188  if (ei > h->ecart && ii < strat->tl)
189  {
190  li = strat->T[j].length;
191  // the polynomial to reduce with (up to the moment) is;
192  // pi with ecart ei and length li
193  // look for one with smaller ecart
194  i = j;
195  loop
196  {
197  /*- takes the first possible with respect to ecart -*/
198  i++;
199 #if 1
200  if (i > strat->tl) break;
201  if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
202  strat->T[i].length < li))
203  &&
204  p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h->GetLmTailRing(), ~h->sev, strat->tailRing))
205 #else
206  j = kFindDivisibleByInT(strat, h, i);
207  if (j < 0) break;
208  i = j;
209  if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
210  strat->T[i].length < li))
211 #endif
212  {
213  // the polynomial to reduce with is now
214  ii = i;
215  ei = strat->T[i].ecart;
216  if (ei <= h->ecart) break;
217  li = strat->T[i].length;
218  }
219  }
220  }
221 
222  // end of search: have to reduce with pi
223  if (ei > h->ecart)
224  {
225  // It is not possible to reduce h with smaller ecart;
226  // if possible h goes to the lazy-set L,i.e
227  // if its position in L would be not the last one
228  strat->fromT = TRUE;
229  if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
230  {
231  h->SetLmCurrRing();
232  if (strat->honey && strat->posInLDependsOnLength)
233  h->SetLength(strat->length_pLength);
234  assume(h->FDeg == h->pFDeg());
235  at = strat->posInL(strat->L,strat->Ll,h,strat);
236  if (at <= strat->Ll)
237  {
238  /*- h will not become the next element to reduce -*/
239  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
240 #ifdef KDEBUG
241  if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
242 #endif
243  h->Clear();
244  strat->fromT = FALSE;
245  return -1;
246  }
247  }
248  }
249 
250  // now we finally can reduce
251  doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
252  strat->fromT=FALSE;
253 
254  // are we done ???
255  if (h->IsNull())
256  {
258  kDeleteLcm(h);
259  h->Clear();
260  return 0;
261  }
262 
263  // NO!
264  h->SetShortExpVector();
265  h->SetpFDeg();
266  if (strat->honey)
267  {
268  if (ei <= h->ecart)
269  h->ecart = d-h->GetpFDeg();
270  else
271  h->ecart = d-h->GetpFDeg()+ei-h->ecart;
272  }
273  else
274  // this has the side effect of setting h->length
275  h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
276 #if 0
277  if (strat->syzComp!=0)
278  {
279  if ((strat->syzComp>0) && (h->Comp() > strat->syzComp))
280  {
281  assume(h->MinComp() > strat->syzComp);
282  if (strat->honey) h->SetLength();
283 #ifdef KDEBUG
284  if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
285 #endif
286  return -2;
287  }
288  }
289 #endif
290  /*- try to reduce the s-polynomial -*/
291  pass++;
292  d = h->GetpFDeg()+h->ecart;
293  /*
294  *test whether the polynomial should go to the lazyset L
295  *-if the degree jumps
296  *-if the number of pre-defined reductions jumps
297  */
298  if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
299  && ((d >= reddeg) || (pass > strat->LazyPass)))
300  {
301  h->SetLmCurrRing();
302  if (strat->honey && strat->posInLDependsOnLength)
303  h->SetLength(strat->length_pLength);
304  assume(h->FDeg == h->pFDeg());
305  at = strat->posInL(strat->L,strat->Ll,h,strat);
306  if (at <= strat->Ll)
307  {
308  int dummy=strat->sl;
309  if (kFindDivisibleByInS(strat, &dummy, h) < 0)
310  {
311  if (strat->honey && !strat->posInLDependsOnLength)
312  h->SetLength(strat->length_pLength);
313  return 1;
314  }
315  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
316 #ifdef KDEBUG
317  if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
318 #endif
319  h->Clear();
320  return -1;
321  }
322  }
323  else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
324  {
325  Print(".%ld",d);mflush();
326  reddeg = d+1;
327  if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
328  {
329  strat->overflow=TRUE;
330  //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
331  h->GetP();
332  at = strat->posInL(strat->L,strat->Ll,h,strat);
333  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
334  h->Clear();
335  return -1;
336  }
337  }
338  }
339 }
340 
341 #ifdef HAVE_RINGS
343 {
344  int i,at,ei,li,ii;
345  int j = 0;
346  int pass = 0;
347  long d,reddeg;
348 
349  d = h->GetpFDeg()+ h->ecart;
350  reddeg = strat->LazyDegree+d;
351  h->SetShortExpVector();
352  loop
353  {
354  j = kFindDivisibleByInT(strat, h);
355  if (j < 0)
356  {
357  // over ZZ: cleanup coefficients by complete reduction with monomials
358  postReduceByMon(h, strat);
359  if(h->p == NULL)
360  {
361  kDeleteLcm(h);
362  h->Clear();
363  return 0;
364  }
365  if (strat->honey) h->SetLength(strat->length_pLength);
366  if(strat->tl >= 0)
367  h->i_r1 = strat->tl;
368  else
369  h->i_r1 = -1;
370  if (h->GetLmTailRing() == NULL)
371  {
372  kDeleteLcm(h);
373  h->Clear();
374  return 0;
375  }
376  return 1;
377  }
378 
379  ei = strat->T[j].ecart;
380  ii = j;
381  if (ei > h->ecart && ii < strat->tl)
382  {
383  li = strat->T[j].length;
384  // the polynomial to reduce with (up to the moment) is;
385  // pi with ecart ei and length li
386  // look for one with smaller ecart
387  i = j;
388  loop
389  {
390  /*- takes the first possible with respect to ecart -*/
391  i++;
392 #if 1
393  if (i > strat->tl) break;
394  if ((strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
395  strat->T[i].length < li))
396  &&
397  p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i], h->GetLmTailRing(), ~h->sev, strat->tailRing)
398  &&
399  n_DivBy(h->p->coef,strat->T[i].p->coef,strat->tailRing->cf))
400 #else
401  j = kFindDivisibleByInT(strat, h, i);
402  if (j < 0) break;
403  i = j;
404  if (strat->T[i].ecart < ei || (strat->T[i].ecart == ei &&
405  strat->T[i].length < li))
406 #endif
407  {
408  // the polynomial to reduce with is now
409  ii = i;
410  ei = strat->T[i].ecart;
411  if (ei <= h->ecart) break;
412  li = strat->T[i].length;
413  }
414  }
415  }
416 
417  // end of search: have to reduce with pi
418  if (ei > h->ecart)
419  {
420  // It is not possible to reduce h with smaller ecart;
421  // if possible h goes to the lazy-set L,i.e
422  // if its position in L would be not the last one
423  strat->fromT = TRUE;
424  if (!TEST_OPT_REDTHROUGH && strat->Ll >= 0) /*- L is not empty -*/
425  {
426  h->SetLmCurrRing();
427  if (strat->honey && strat->posInLDependsOnLength)
428  h->SetLength(strat->length_pLength);
429  assume(h->FDeg == h->pFDeg());
430  at = strat->posInL(strat->L,strat->Ll,h,strat);
431  if (at <= strat->Ll && pLmCmp(h->p, strat->L[strat->Ll].p) != 0 && !nEqual(h->p->coef, strat->L[strat->Ll].p->coef))
432  {
433  /*- h will not become the next element to reduce -*/
434  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
435  #ifdef KDEBUG
436  if (TEST_OPT_DEBUG) Print(" ecart too big; -> L%d\n",at);
437  #endif
438  h->Clear();
439  strat->fromT = FALSE;
440  return -1;
441  }
442  }
443  doRed(h,&(strat->T[ii]),strat->fromT,strat,TRUE);
444  }
445  else
446  {
447  // now we finally can reduce
448  doRed(h,&(strat->T[ii]),strat->fromT,strat,FALSE);
449  }
450  strat->fromT=FALSE;
451  // are we done ???
452  if (h->IsNull())
453  {
454  kDeleteLcm(h);
455  h->Clear();
456  return 0;
457  }
458 
459  // NO!
460  h->SetShortExpVector();
461  h->SetpFDeg();
462  if (strat->honey)
463  {
464  if (ei <= h->ecart)
465  h->ecart = d-h->GetpFDeg();
466  else
467  h->ecart = d-h->GetpFDeg()+ei-h->ecart;
468  }
469  else
470  // this has the side effect of setting h->length
471  h->ecart = h->pLDeg(strat->LDegLast) - h->GetpFDeg();
472  /*- try to reduce the s-polynomial -*/
473  pass++;
474  d = h->GetpFDeg()+h->ecart;
475  /*
476  *test whether the polynomial should go to the lazyset L
477  *-if the degree jumps
478  *-if the number of pre-defined reductions jumps
479  */
480  if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
481  && ((d >= reddeg) || (pass > strat->LazyPass)))
482  {
483  h->SetLmCurrRing();
484  if (strat->honey && strat->posInLDependsOnLength)
485  h->SetLength(strat->length_pLength);
486  assume(h->FDeg == h->pFDeg());
487  at = strat->posInL(strat->L,strat->Ll,h,strat);
488  if (at <= strat->Ll)
489  {
490  int dummy=strat->sl;
491  if (kFindDivisibleByInS(strat, &dummy, h) < 0)
492  {
493  if (strat->honey && !strat->posInLDependsOnLength)
494  h->SetLength(strat->length_pLength);
495  return 1;
496  }
497  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
498 #ifdef KDEBUG
499  if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
500 #endif
501  h->Clear();
502  return -1;
503  }
504  }
505  else if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
506  {
507  Print(".%ld",d);mflush();
508  reddeg = d+1;
509  if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
510  {
511  strat->overflow=TRUE;
512  //Print("OVERFLOW in redEcart d=%ld, max=%ld",d,strat->tailRing->bitmask);
513  h->GetP();
514  at = strat->posInL(strat->L,strat->Ll,h,strat);
515  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
516  h->Clear();
517  return -1;
518  }
519  }
520  }
521 }
522 #endif
523 
524 /*2
525 *reduces h with elements from T choosing the first possible
526 * element in t with respect to the given pDivisibleBy
527 */
529 {
530  if (h->IsNull()) return 0;
531 
532  int at;
533  long reddeg,d;
534  int pass = 0;
535  int j = 0;
536 
537  if (! strat->homog)
538  {
539  d = h->GetpFDeg() + h->ecart;
540  reddeg = strat->LazyDegree+d;
541  }
542  h->SetShortExpVector();
543  loop
544  {
545  j = kFindDivisibleByInT(strat, h);
546  if (j < 0)
547  {
548  h->SetDegStuffReturnLDeg(strat->LDegLast);
549  return 1;
550  }
551 
553  strat->T[j].pNorm();
554 #ifdef KDEBUG
555  if (TEST_OPT_DEBUG)
556  {
557  PrintS("reduce ");
558  h->wrp();
559  PrintS(" with ");
560  strat->T[j].wrp();
561  }
562 #endif
563  ksReducePoly(h, &(strat->T[j]), strat->kNoetherTail(), NULL, strat);
564 #ifdef KDEBUG
565  if (TEST_OPT_DEBUG)
566  {
567  PrintS(" to ");
568  wrp(h->p);
569  PrintLn();
570  }
571 #endif
572  if (h->IsNull())
573  {
575  kDeleteLcm(h);
576  h->Clear();
577  return 0;
578  }
579  h->SetShortExpVector();
580 
581 #if 0
582  if ((strat->syzComp!=0) && !strat->honey)
583  {
584  if ((strat->syzComp>0) &&
585  (h->Comp() > strat->syzComp))
586  {
587  assume(h->MinComp() > strat->syzComp);
588 #ifdef KDEBUG
589  if (TEST_OPT_DEBUG) PrintS(" > syzComp\n");
590 #endif
591  if (strat->homog)
592  h->SetDegStuffReturnLDeg(strat->LDegLast);
593  return -2;
594  }
595  }
596 #endif
597  if (!strat->homog)
598  {
599  if (!TEST_OPT_OLDSTD && strat->honey)
600  {
601  h->SetpFDeg();
602  if (strat->T[j].ecart <= h->ecart)
603  h->ecart = d - h->GetpFDeg();
604  else
605  h->ecart = d - h->GetpFDeg() + strat->T[j].ecart - h->ecart;
606 
607  d = h->GetpFDeg() + h->ecart;
608  }
609  else
610  d = h->SetDegStuffReturnLDeg(strat->LDegLast);
611  /*- try to reduce the s-polynomial -*/
612  pass++;
613  /*
614  *test whether the polynomial should go to the lazyset L
615  *-if the degree jumps
616  *-if the number of pre-defined reductions jumps
617  */
618  if (!TEST_OPT_REDTHROUGH && (strat->Ll >= 0)
619  && ((d >= reddeg) || (pass > strat->LazyPass)))
620  {
621  h->SetLmCurrRing();
622  if (strat->posInLDependsOnLength)
623  h->SetLength(strat->length_pLength);
624  at = strat->posInL(strat->L,strat->Ll,h,strat);
625  if (at <= strat->Ll)
626  {
627  int dummy=strat->sl;
628  if (kFindDivisibleByInS(strat,&dummy, h) < 0)
629  return 1;
630  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
631 #ifdef KDEBUG
632  if (TEST_OPT_DEBUG) Print(" degree jumped; ->L%d\n",at);
633 #endif
634  h->Clear();
635  return -1;
636  }
637  }
638  if ((TEST_OPT_PROT) && (strat->Ll < 0) && (d >= reddeg))
639  {
640  reddeg = d+1;
641  Print(".%ld",d);mflush();
642  if (h->pTotalDeg()+h->ecart >= (int)strat->tailRing->bitmask)
643  {
644  strat->overflow=TRUE;
645  //Print("OVERFLOW in redFirst d=%ld, max=%ld",d,strat->tailRing->bitmask);
646  h->GetP();
647  at = strat->posInL(strat->L,strat->Ll,h,strat);
648  enterL(&strat->L,&strat->Ll,&strat->Lmax,*h,at);
649  h->Clear();
650  return -1;
651  }
652  }
653  }
654  }
655 }
656 
657 /*2
658 * reduces h with elements from T choosing first possible
659 * element in T with respect to the given ecart
660 * used for computing normal forms outside kStd
661 */
662 static poly redMoraNF (poly h,kStrategy strat, int flag)
663 {
664  LObject H;
665  H.p = h;
666  int j = 0;
667  int z = 10;
668  int o = H.SetpFDeg();
669  H.ecart = currRing->pLDeg(H.p,&H.length,currRing)-o;
670  if ((flag & 2) == 0) cancelunit(&H,TRUE);
671  H.sev = pGetShortExpVector(H.p);
672  unsigned long not_sev = ~ H.sev;
673  loop
674  {
675  if (j > strat->tl)
676  {
677  return H.p;
678  }
679  if (TEST_V_DEG_STOP)
680  {
681  if (kModDeg(H.p)>Kstd1_deg) pLmDelete(&H.p);
682  if (H.p==NULL) return NULL;
683  }
684  if (p_LmShortDivisibleBy(strat->T[j].GetLmTailRing(), strat->sevT[j], H.GetLmTailRing(), not_sev, strat->tailRing)
685  )
686  {
687  /*- remember the found T-poly -*/
688  // poly pi = strat->T[j].p;
689  int ei = strat->T[j].ecart;
690  int li = strat->T[j].length;
691  int ii = j;
692  /*
693  * the polynomial to reduce with (up to the moment) is;
694  * pi with ecart ei and length li
695  */
696  loop
697  {
698  /*- look for a better one with respect to ecart -*/
699  /*- stop, if the ecart is small enough (<=ecart(H)) -*/
700  j++;
701  if (j > strat->tl) break;
702  if (ei <= H.ecart) break;
703  if (((strat->T[j].ecart < ei)
704  || ((strat->T[j].ecart == ei)
705  && (strat->T[j].length < li)))
706  && pLmShortDivisibleBy(strat->T[j].p,strat->sevT[j], H.p, not_sev)
707  )
708  {
709  /*
710  * the polynomial to reduce with is now;
711  */
712  // pi = strat->T[j].p;
713  ei = strat->T[j].ecart;
714  li = strat->T[j].length;
715  ii = j;
716  }
717  }
718  /*
719  * end of search: have to reduce with pi
720  */
721  z++;
722  if (z>10)
723  {
724  pNormalize(H.p);
725  z=0;
726  }
727  if ((ei > H.ecart) && (!strat->kHEdgeFound))
728  {
729  /*
730  * It is not possible to reduce h with smaller ecart;
731  * we have to reduce with bad ecart: H has to enter in T
732  */
733  doRed(&H,&(strat->T[ii]),TRUE,strat,TRUE);
734  if (H.p == NULL)
735  return NULL;
736  }
737  else
738  {
739  /*
740  * we reduce with good ecart, h need not to be put to T
741  */
742  doRed(&H,&(strat->T[ii]),FALSE,strat,TRUE);
743  if (H.p == NULL)
744  return NULL;
745  }
746  /*- try to reduce the s-polynomial -*/
747  o = H.SetpFDeg();
748  if ((flag &2 ) == 0) cancelunit(&H,TRUE);
749  H.ecart = currRing->pLDeg(H.p,&(H.length),currRing)-o;
750  j = 0;
751  H.sev = pGetShortExpVector(H.p);
752  not_sev = ~ H.sev;
753  }
754  else
755  {
756  j++;
757  }
758  }
759 }
760 
761 #ifdef HAVE_RINGS
762 static poly redMoraNFRing (poly h,kStrategy strat, int flag)
763 {
764  LObject H;
765  H.p = h;
766  int j = 0;
767  int z = 10;
768  int o = H.SetpFDeg();
769  H.ecart = currRing->pLDeg(H.p,&H.length,currRing)-o;
770  if ((flag & 2) == 0) cancelunit(&H,TRUE);
771  H.sev = pGetShortExpVector(H.p);
772  unsigned long not_sev = ~ H.sev;
773  loop
774  {
775  if (j > strat->tl)
776  {
777  return H.p;
778  }
779  if (TEST_V_DEG_STOP)
780  {
781  if (kModDeg(H.p)>Kstd1_deg) pLmDelete(&H.p);
782  if (H.p==NULL) return NULL;
783  }
784  if (p_LmShortDivisibleBy(strat->T[j].GetLmTailRing(), strat->sevT[j], H.GetLmTailRing(), not_sev, strat->tailRing)
785  && (n_DivBy(H.p->coef, strat->T[j].p->coef,strat->tailRing->cf))
786  )
787  {
788  /*- remember the found T-poly -*/
789  // poly pi = strat->T[j].p;
790  int ei = strat->T[j].ecart;
791  int li = strat->T[j].length;
792  int ii = j;
793  /*
794  * the polynomial to reduce with (up to the moment) is;
795  * pi with ecart ei and length li
796  */
797  loop
798  {
799  /*- look for a better one with respect to ecart -*/
800  /*- stop, if the ecart is small enough (<=ecart(H)) -*/
801  j++;
802  if (j > strat->tl) break;
803  if (ei <= H.ecart) break;
804  if (((strat->T[j].ecart < ei)
805  || ((strat->T[j].ecart == ei)
806  && (strat->T[j].length < li)))
807  && pLmShortDivisibleBy(strat->T[j].p,strat->sevT[j], H.p, not_sev)
808  && (n_DivBy(H.p->coef, strat->T[j].p->coef,strat->tailRing->cf))
809  )
810  {
811  /*
812  * the polynomial to reduce with is now;
813  */
814  // pi = strat->T[j].p;
815  ei = strat->T[j].ecart;
816  li = strat->T[j].length;
817  ii = j;
818  }
819  }
820  /*
821  * end of search: have to reduce with pi
822  */
823  z++;
824  if (z>10)
825  {
826  pNormalize(H.p);
827  z=0;
828  }
829  if ((ei > H.ecart) && (!strat->kHEdgeFound))
830  {
831  /*
832  * It is not possible to reduce h with smaller ecart;
833  * we have to reduce with bad ecart: H has to enter in T
834  */
835  doRed(&H,&(strat->T[ii]),TRUE,strat,TRUE);
836  if (H.p == NULL)
837  return NULL;
838  }
839  else
840  {
841  /*
842  * we reduce with good ecart, h need not to be put to T
843  */
844  doRed(&H,&(strat->T[ii]),FALSE,strat,TRUE);
845  if (H.p == NULL)
846  return NULL;
847  }
848  /*- try to reduce the s-polynomial -*/
849  o = H.SetpFDeg();
850  if ((flag &2 ) == 0) cancelunit(&H,TRUE);
851  H.ecart = currRing->pLDeg(H.p,&(H.length),currRing)-o;
852  j = 0;
853  H.sev = pGetShortExpVector(H.p);
854  not_sev = ~ H.sev;
855  }
856  else
857  {
858  j++;
859  }
860  }
861 }
862 #endif
863 
864 /*2
865 *reorders L with respect to posInL
866 */
867 void reorderL(kStrategy strat)
868 {
869  int i,j,at;
870  LObject p;
871 
872  for (i=1; i<=strat->Ll; i++)
873  {
874  at = strat->posInL(strat->L,i-1,&(strat->L[i]),strat);
875  if (at != i)
876  {
877  p = strat->L[i];
878  for (j=i-1; j>=at; j--) strat->L[j+1] = strat->L[j];
879  strat->L[at] = p;
880  }
881  }
882 }
883 
884 /*2
885 *reorders T with respect to length
886 */
887 void reorderT(kStrategy strat)
888 {
889  int i,j,at;
890  TObject p;
891  unsigned long sev;
892 
893 
894  for (i=1; i<=strat->tl; i++)
895  {
896  if (strat->T[i-1].length > strat->T[i].length)
897  {
898  p = strat->T[i];
899  sev = strat->sevT[i];
900  at = i-1;
901  loop
902  {
903  at--;
904  if (at < 0) break;
905  if (strat->T[i].length > strat->T[at].length) break;
906  }
907  for (j = i-1; j>at; j--)
908  {
909  strat->T[j+1]=strat->T[j];
910  strat->sevT[j+1]=strat->sevT[j];
911  strat->R[strat->T[j+1].i_r] = &(strat->T[j+1]);
912  }
913  strat->T[at+1]=p;
914  strat->sevT[at+1] = sev;
915  strat->R[p.i_r] = &(strat->T[at+1]);
916  }
917  }
918 }
919 
920 /*2
921 *looks whether exactly (currRing->N)-1 axis are used
922 *returns last != 0 in this case
923 *last is the (first) unused axis
924 */
925 void missingAxis (int* last,kStrategy strat)
926 {
927  int i = 0;
928  int k = 0;
929 
930  *last = 0;
932  {
933  loop
934  {
935  i++;
936  if (i > (currRing->N)) break;
937  if (strat->NotUsedAxis[i])
938  {
939  *last = i;
940  k++;
941  }
942  if (k>1)
943  {
944  *last = 0;
945  break;
946  }
947  }
948  }
949 }
950 
951 /*2
952 *last is the only non used axis, it looks
953 *for a monomial in p being a pure power of this
954 *variable and returns TRUE in this case
955 *(*length) gives the length between the pure power and the leading term
956 *(should be minimal)
957 */
958 BOOLEAN hasPurePower (const poly p,int last, int *length,kStrategy strat)
959 {
960  poly h;
961  int i;
962 
963  if (pNext(p) == strat->tail)
964  return FALSE;
965  pp_Test(p, currRing, strat->tailRing);
966  if (strat->ak <= 0 || p_MinComp(p, currRing, strat->tailRing) == strat->ak)
967  {
968  i = p_IsPurePower(p, currRing);
969  if (rField_is_Ring(currRing) && (!n_IsUnit(pGetCoeff(p), currRing->cf))) i=0;
970  if (i == last)
971  {
972  *length = 0;
973  return TRUE;
974  }
975  *length = 1;
976  h = pNext(p);
977  while (h != NULL)
978  {
979  i = p_IsPurePower(h, strat->tailRing);
980  if (rField_is_Ring(currRing) && (!n_IsUnit(pGetCoeff(h), currRing->cf))) i=0;
981  if (i==last) return TRUE;
982  (*length)++;
983  pIter(h);
984  }
985  }
986  return FALSE;
987 }
988 
990 {
991  if (L->bucket != NULL)
992  {
993  poly p = L->GetP();
994  return hasPurePower(p, last, length, strat);
995  }
996  else
997  {
998  return hasPurePower(L->p, last, length, strat);
999  }
1000 }
1001 
1002 /*2
1003 * looks up the position of polynomial p in L
1004 * in the case of looking for the pure powers
1005 */
1006 int posInL10 (const LSet set,const int length, LObject* p,const kStrategy strat)
1007 {
1008  int j,dp,dL;
1009 
1010  if (length<0) return 0;
1011  if (hasPurePower(p,strat->lastAxis,&dp,strat))
1012  {
1013  int op= p->GetpFDeg() +p->ecart;
1014  for (j=length; j>=0; j--)
1015  {
1016  if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat))
1017  return j+1;
1018  if (dp < dL)
1019  return j+1;
1020  if ((dp == dL)
1021  && (set[j].GetpFDeg()+set[j].ecart >= op))
1022  return j+1;
1023  }
1024  }
1025  j=length;
1026  loop
1027  {
1028  if (j<0) break;
1029  if (!hasPurePower(&(set[j]),strat->lastAxis,&dL,strat)) break;
1030  j--;
1031  }
1032  return strat->posInLOld(set,j,p,strat);
1033 }
1034 
1035 
1036 /*2
1037 * computes the s-polynomials L[ ].p in L
1038 */
1039 void updateL(kStrategy strat)
1040 {
1041  LObject p;
1042  int dL;
1043  int j=strat->Ll;
1044  loop
1045  {
1046  if (j<0) break;
1047  if (hasPurePower(&(strat->L[j]),strat->lastAxis,&dL,strat))
1048  {
1049  p=strat->L[strat->Ll];
1050  strat->L[strat->Ll]=strat->L[j];
1051  strat->L[j]=p;
1052  break;
1053  }
1054  j--;
1055  }
1056  if (j<0)
1057  {
1058  j=strat->Ll;
1059  loop
1060  {
1061  if (j<0) break;
1062  if (pNext(strat->L[j].p) == strat->tail)
1063  {
1064  if (rField_is_Ring(currRing))
1065  pLmDelete(strat->L[j].p); /*deletes the short spoly and computes*/
1066  else
1067  pLmFree(strat->L[j].p); /*deletes the short spoly and computes*/
1068  strat->L[j].p = NULL;
1069  poly m1 = NULL, m2 = NULL;
1070  // check that spoly creation is ok
1071  while (strat->tailRing != currRing &&
1072  !kCheckSpolyCreation(&(strat->L[j]), strat, m1, m2))
1073  {
1074  assume(m1 == NULL && m2 == NULL);
1075  // if not, change to a ring where exponents are at least
1076  // large enough
1077  kStratChangeTailRing(strat);
1078  }
1079  /* create the real one */
1080  ksCreateSpoly(&(strat->L[j]), strat->kNoetherTail(), FALSE,
1081  strat->tailRing, m1, m2, strat->R);
1082 
1083  strat->L[j].SetLmCurrRing();
1084  if (!strat->honey)
1085  strat->initEcart(&strat->L[j]);
1086  else
1087  strat->L[j].SetLength(strat->length_pLength);
1088 
1089  BOOLEAN pp = hasPurePower(&(strat->L[j]),strat->lastAxis,&dL,strat);
1090 
1091  if (strat->use_buckets) strat->L[j].PrepareRed(TRUE);
1092 
1093  if (pp)
1094  {
1095  p=strat->L[strat->Ll];
1096  strat->L[strat->Ll]=strat->L[j];
1097  strat->L[j]=p;
1098  break;
1099  }
1100  }
1101  j--;
1102  }
1103  }
1104 }
1105 
1106 /*2
1107 * computes the s-polynomials L[ ].p in L and
1108 * cuts elements in L above noether
1109 */
1111 {
1112 
1113  int i = 0;
1114  kTest_TS(strat);
1115  while (i <= strat->Ll)
1116  {
1117  if (pNext(strat->L[i].p) == strat->tail)
1118  {
1119  /*- deletes the int spoly and computes -*/
1120  if (pLmCmp(strat->L[i].p,strat->kNoether) == -1)
1121  {
1122  if (rField_is_Ring(currRing))
1123  pLmDelete(strat->L[i].p);
1124  else
1125  pLmFree(strat->L[i].p);
1126  strat->L[i].p = NULL;
1127  }
1128  else
1129  {
1130  if (rField_is_Ring(currRing))
1131  pLmDelete(strat->L[i].p);
1132  else
1133  pLmFree(strat->L[i].p);
1134  strat->L[i].p = NULL;
1135  poly m1 = NULL, m2 = NULL;
1136  // check that spoly creation is ok
1137  while (strat->tailRing != currRing &&
1138  !kCheckSpolyCreation(&(strat->L[i]), strat, m1, m2))
1139  {
1140  assume(m1 == NULL && m2 == NULL);
1141  // if not, change to a ring where exponents are at least
1142  // large enough
1143  kStratChangeTailRing(strat);
1144  }
1145  /* create the real one */
1146  ksCreateSpoly(&(strat->L[i]), strat->kNoetherTail(), FALSE,
1147  strat->tailRing, m1, m2, strat->R);
1148  if (! strat->L[i].IsNull())
1149  {
1150  strat->L[i].SetLmCurrRing();
1151  strat->L[i].SetpFDeg();
1152  strat->L[i].ecart
1153  = strat->L[i].pLDeg(strat->LDegLast) - strat->L[i].GetpFDeg();
1154  if (strat->use_buckets) strat->L[i].PrepareRed(TRUE);
1155  }
1156  }
1157  }
1158  else
1159  deleteHC(&(strat->L[i]), strat);
1160  if (strat->L[i].IsNull())
1161  deleteInL(strat->L,&strat->Ll,i,strat);
1162  else
1163  {
1164 #ifdef KDEBUG
1165  kTest_L(&(strat->L[i]), strat->tailRing, TRUE, i, strat->T, strat->tl);
1166 #endif
1167  i++;
1168  }
1169  }
1170  kTest_TS(strat);
1171 }
1172 
1173 /*2
1174 * cuts in T above strat->kNoether and tries to cancel a unit
1175 * changes also S as S is a subset of T
1176 */
1177 void updateT(kStrategy strat)
1178 {
1179  int i = 0;
1180  LObject p;
1181 
1182  while (i <= strat->tl)
1183  {
1184  p = strat->T[i];
1185  deleteHC(&p,strat, TRUE);
1186  /*- tries to cancel a unit: -*/
1187  cancelunit(&p);
1188  if (TEST_OPT_INTSTRATEGY) /* deleteHC and/or cancelunit may have changed p*/
1189  p.pCleardenom();
1190  if (p.p != strat->T[i].p)
1191  {
1192  strat->sevT[i] = pGetShortExpVector(p.p);
1193  p.SetpFDeg();
1194  }
1195  strat->T[i] = p;
1196  i++;
1197  }
1198 }
1199 
1200 /*2
1201 * arranges red, pos and T if strat->kHEdgeFound (first time)
1202 */
1204 {
1205  if (strat->update)
1206  {
1207  kTest_TS(strat);
1208  strat->update = (strat->tl == -1);
1209  if (TEST_OPT_WEIGHTM)
1210  {
1211  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1212  if (strat->tailRing != currRing)
1213  {
1214  strat->tailRing->pFDeg = strat->pOrigFDeg_TailRing;
1215  strat->tailRing->pLDeg = strat->pOrigLDeg_TailRing;
1216  }
1217  int i;
1218  for (i=strat->Ll; i>=0; i--)
1219  {
1220  strat->L[i].SetpFDeg();
1221  }
1222  for (i=strat->tl; i>=0; i--)
1223  {
1224  strat->T[i].SetpFDeg();
1225  }
1226  if (ecartWeights)
1227  {
1228  omFreeSize((ADDRESS)ecartWeights,(rVar(currRing)+1)*sizeof(short));
1229  ecartWeights=NULL;
1230  }
1231  }
1232  if (TEST_OPT_FASTHC)
1233  {
1234  strat->posInL = strat->posInLOld;
1235  strat->lastAxis = 0;
1236  }
1237  if (TEST_OPT_FINDET)
1238  return;
1239 
1241  {
1242  strat->red = redFirst;
1243  strat->use_buckets = kMoraUseBucket(strat);
1244  }
1245  updateT(strat);
1246 
1248  {
1249  strat->posInT = posInT2;
1250  reorderT(strat);
1251  }
1252  }
1253  kTest_TS(strat);
1254 }
1255 
1256 /*2
1257 *-puts p to the standardbasis s at position at
1258 *-reduces the tail of p if TEST_OPT_REDTAIL
1259 *-tries to cancel a unit
1260 *-HEckeTest
1261 * if TRUE
1262 * - decides about reduction-strategies
1263 * - computes noether
1264 * - stops computation if TEST_OPT_FINDET
1265 * - cuts the tails of the polynomials
1266 * in s,t and the elements in L above noether
1267 * and cancels units if possible
1268 * - reorders s,L
1269 */
1270 void enterSMora (LObject &p,int atS,kStrategy strat, int atR = -1)
1271 {
1272  enterSBba(p, atS, strat, atR);
1273  #ifdef KDEBUG
1274  if (TEST_OPT_DEBUG)
1275  {
1276  Print("new s%d:",atS);
1277  p_wrp(p.p,currRing,strat->tailRing);
1278  PrintLn();
1279  }
1280  #endif
1281  if ((!strat->kHEdgeFound) || (strat->kNoether!=NULL)) HEckeTest(p.p,strat);
1282  if (strat->kHEdgeFound)
1283  {
1284  if (newHEdge(strat))
1285  {
1286  firstUpdate(strat);
1287  if (TEST_OPT_FINDET)
1288  return;
1289 
1290  /*- cuts elements in L above noether and reorders L -*/
1291  updateLHC(strat);
1292  /*- reorders L with respect to posInL -*/
1293  reorderL(strat);
1294  }
1295  }
1296  else if (strat->kNoether!=NULL)
1297  strat->kHEdgeFound = TRUE;
1298  else if (TEST_OPT_FASTHC)
1299  {
1300  if (strat->posInLOldFlag)
1301  {
1302  missingAxis(&strat->lastAxis,strat);
1303  if (strat->lastAxis)
1304  {
1305  strat->posInLOld = strat->posInL;
1306  strat->posInLOldFlag = FALSE;
1307  strat->posInL = posInL10;
1308  strat->posInLDependsOnLength = TRUE;
1309  updateL(strat);
1310  reorderL(strat);
1311  }
1312  }
1313  else if (strat->lastAxis)
1314  updateL(strat);
1315  }
1316 }
1317 
1318 /*2
1319 *-puts p to the standardbasis s at position at
1320 *-HEckeTest
1321 * if TRUE
1322 * - computes noether
1323 */
1324 void enterSMoraNF (LObject &p, int atS,kStrategy strat, int atR = -1)
1325 {
1326  enterSBba(p, atS, strat, atR);
1327  if ((!strat->kHEdgeFound) || (strat->kNoether!=NULL)) HEckeTest(p.p,strat);
1328  if (strat->kHEdgeFound)
1329  newHEdge(strat);
1330  else if (strat->kNoether!=NULL)
1331  strat->kHEdgeFound = TRUE;
1332 }
1333 
1334 void initBba(kStrategy strat)
1335 {
1336  /* setting global variables ------------------- */
1337  strat->enterS = enterSBba;
1338  strat->red = redHoney;
1339  if (strat->honey)
1340  strat->red = redHoney;
1341  else if (currRing->pLexOrder && !strat->homog)
1342  strat->red = redLazy;
1343  else
1344  {
1345  strat->LazyPass *=4;
1346  strat->red = redHomog;
1347  }
1348  if (rField_is_Ring(currRing))
1349  {
1350  if (rField_is_Z(currRing))
1351  strat->red = redRing_Z;
1352  else
1353  strat->red = redRing;
1354  }
1355  if (currRing->pLexOrder && strat->honey)
1356  strat->initEcart = initEcartNormal;
1357  else
1358  strat->initEcart = initEcartBBA;
1359  if (strat->honey)
1361  else
1363 // if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1364 // {
1365 // //interred machen Aenderung
1366 // strat->pOrigFDeg=pFDeg;
1367 // strat->pOrigLDeg=pLDeg;
1368 // //h=ggetid("ecart");
1369 // //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1370 // //{
1371 // // ecartWeights=iv2array(IDINTVEC(h));
1372 // //}
1373 // //else
1374 // {
1375 // ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1376 // /*uses automatic computation of the ecartWeights to set them*/
1377 // kEcartWeights(F->m,IDELEMS(F)-1,ecartWeights);
1378 // }
1379 // pRestoreDegProcs(currRing,totaldegreeWecart, maxdegreeWecart);
1380 // if (TEST_OPT_PROT)
1381 // {
1382 // for(i=1; i<=(currRing->N); i++)
1383 // Print(" %d",ecartWeights[i]);
1384 // PrintLn();
1385 // mflush();
1386 // }
1387 // }
1388 }
1389 
1390 void initSba(ideal F,kStrategy strat)
1391 {
1392  int i;
1393  //idhdl h;
1394  /* setting global variables ------------------- */
1395  strat->enterS = enterSSba;
1396  strat->red2 = redHoney;
1397  if (strat->honey)
1398  strat->red2 = redHoney;
1399  else if (currRing->pLexOrder && !strat->homog)
1400  strat->red2 = redLazy;
1401  else
1402  {
1403  strat->LazyPass *=4;
1404  strat->red2 = redHomog;
1405  }
1406  if (rField_is_Ring(currRing))
1407  {
1409  {strat->red2 = redRiloc;}
1410  else
1411  {strat->red2 = redRing;}
1412  }
1413  if (currRing->pLexOrder && strat->honey)
1414  strat->initEcart = initEcartNormal;
1415  else
1416  strat->initEcart = initEcartBBA;
1417  if (strat->honey)
1419  else
1421  //strat->kIdeal = NULL;
1422  //if (strat->ak==0) strat->kIdeal->rtyp=IDEAL_CMD;
1423  //else strat->kIdeal->rtyp=MODUL_CMD;
1424  //strat->kIdeal->data=(void *)strat->Shdl;
1425  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1426  {
1427  //interred machen Aenderung
1428  strat->pOrigFDeg = currRing->pFDeg;
1429  strat->pOrigLDeg = currRing->pLDeg;
1430  //h=ggetid("ecart");
1431  //if ((h!=NULL) /*&& (IDTYP(h)==INTVEC_CMD)*/)
1432  //{
1433  // ecartWeights=iv2array(IDINTVEC(h));
1434  //}
1435  //else
1436  {
1437  ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1438  /*uses automatic computation of the ecartWeights to set them*/
1440  }
1442  if (TEST_OPT_PROT)
1443  {
1444  for(i=1; i<=(currRing->N); i++)
1445  Print(" %d",ecartWeights[i]);
1446  PrintLn();
1447  mflush();
1448  }
1449  }
1450  // for sig-safe reductions in signature-based
1451  // standard basis computations
1453  strat->red = redSigRing;
1454  else
1455  strat->red = redSig;
1456  //strat->sbaOrder = 1;
1457  strat->currIdx = 1;
1458 }
1459 
1460 void initMora(ideal F,kStrategy strat)
1461 {
1462  int i,j;
1463 
1464  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
1465  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
1466  strat->enterS = enterSMora;
1467  strat->initEcartPair = initEcartPairMora; /*- ecart approximation -*/
1468  strat->posInLOld = strat->posInL;
1469  strat->posInLOldFlag = TRUE;
1470  strat->initEcart = initEcartNormal;
1471  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1472  if ( strat->kHEdgeFound )
1473  strat->kNoether = pCopy((currRing->ppNoether));
1474  else if (strat->kHEdgeFound || strat->homog)
1475  strat->red = redFirst; /*take the first possible in T*/
1476  else
1477  strat->red = redEcart;/*take the first possible in under ecart-restriction*/
1478  if (strat->kHEdgeFound)
1479  {
1480  strat->HCord = currRing->pFDeg((currRing->ppNoether),currRing)+1;
1481  strat->posInT = posInT2;
1482  }
1483  else
1484  {
1485  strat->HCord = 32000;/*- very large -*/
1486  }
1487 
1488  if (rField_is_Ring(currRing))
1489  strat->red = redRiloc;
1490 
1491  /*reads the ecartWeights used for Graebes method from the
1492  *intvec ecart and set ecartWeights
1493  */
1494  if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1495  {
1496  //interred machen Aenderung
1497  strat->pOrigFDeg=currRing->pFDeg;
1498  strat->pOrigLDeg=currRing->pLDeg;
1499  ecartWeights=(short *)omAlloc(((currRing->N)+1)*sizeof(short));
1500  /*uses automatic computation of the ecartWeights to set them*/
1502 
1504  if (TEST_OPT_PROT)
1505  {
1506  for(i=1; i<=(currRing->N); i++)
1507  Print(" %d",ecartWeights[i]);
1508  PrintLn();
1509  mflush();
1510  }
1511  }
1512  kOptimizeLDeg(currRing->pLDeg, strat);
1513 }
1514 
1515 void kDebugPrint(kStrategy strat);
1516 
1517 ideal mora (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat)
1518 {
1519  int olddeg = 0;
1520  int reduc = 0;
1521  int red_result = 1;
1522  int hilbeledeg=1,hilbcount=0;
1523  BITSET save1;
1524  SI_SAVE_OPT1(save1);
1526  {
1527  si_opt_1 &= ~Sy_bit(OPT_REDSB);
1529  }
1530 
1531  strat->update = TRUE;
1532  /*- setting global variables ------------------- -*/
1533  initBuchMoraCrit(strat);
1534  initHilbCrit(F,Q,&hilb,strat);
1535  initMora(F,strat);
1537  initBuchMoraPosRing(strat);
1538  else
1539  initBuchMoraPos(strat);
1540  /*Shdl=*/initBuchMora(F,Q,strat);
1541  if (TEST_OPT_FASTHC) missingAxis(&strat->lastAxis,strat);
1542  /*updateS in initBuchMora has Hecketest
1543  * and could have put strat->kHEdgdeFound FALSE*/
1544  if ((currRing->ppNoether)!=NULL)
1545  {
1546  strat->kHEdgeFound = TRUE;
1547  }
1548  if (strat->kHEdgeFound && strat->update)
1549  {
1550  firstUpdate(strat);
1551  updateLHC(strat);
1552  reorderL(strat);
1553  }
1554  if (TEST_OPT_FASTHC && (strat->lastAxis) && strat->posInLOldFlag)
1555  {
1556  strat->posInLOld = strat->posInL;
1557  strat->posInLOldFlag = FALSE;
1558  strat->posInL = posInL10;
1559  updateL(strat);
1560  reorderL(strat);
1561  }
1562  kTest_TS(strat);
1563  strat->use_buckets = kMoraUseBucket(strat);
1564 
1565 #ifdef HAVE_TAIL_RING
1566  if (strat->homog && strat->red == redFirst)
1567  if(!idIs0(F) &&(!rField_is_Ring(currRing)))
1568  kStratInitChangeTailRing(strat);
1569 #endif
1570 
1571  if (BVERBOSE(23))
1572  {
1573  kDebugPrint(strat);
1574  }
1575 //deleteInL(strat->L,&strat->Ll,1,strat);
1576 //deleteInL(strat->L,&strat->Ll,0,strat);
1577 
1578  /*- compute-------------------------------------------*/
1579  while (strat->Ll >= 0)
1580  {
1581  #ifdef KDEBUG
1582  if (TEST_OPT_DEBUG) messageSets(strat);
1583  #endif
1584  if (siCntrlc)
1585  {
1586  while (strat->Ll >= 0)
1587  deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1588  strat->noClearS=TRUE;
1589  }
1590  if (TEST_OPT_DEGBOUND
1591  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg))
1592  {
1593  /*
1594  * stops computation if
1595  * - 24 (degBound)
1596  * && upper degree is bigger than Kstd1_deg
1597  */
1598  while ((strat->Ll >= 0)
1599  && (strat->L[strat->Ll].p1!=NULL) && (strat->L[strat->Ll].p2!=NULL)
1600  && (strat->L[strat->Ll].ecart+strat->L[strat->Ll].GetpFDeg()> Kstd1_deg)
1601  )
1602  {
1603  deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1604  //if (TEST_OPT_PROT)
1605  //{
1606  // PrintS("D"); mflush();
1607  //}
1608  }
1609  if (strat->Ll<0) break;
1610  else strat->noClearS=TRUE;
1611  }
1612  strat->P = strat->L[strat->Ll];/*- picks the last element from the lazyset L -*/
1613  if (strat->Ll==0) strat->interpt=TRUE;
1614  strat->Ll--;
1615  // create the real Spoly
1616  if (pNext(strat->P.p) == strat->tail)
1617  {
1618  /*- deletes the short spoly and computes -*/
1619  if (rField_is_Ring(currRing))
1620  pLmDelete(strat->P.p);
1621  else
1622  pLmFree(strat->P.p);
1623  strat->P.p = NULL;
1624  poly m1 = NULL, m2 = NULL;
1625  // check that spoly creation is ok
1626  while (strat->tailRing != currRing &&
1627  !kCheckSpolyCreation(&(strat->P), strat, m1, m2))
1628  {
1629  assume(m1 == NULL && m2 == NULL);
1630  // if not, change to a ring where exponents are large enough
1631  kStratChangeTailRing(strat);
1632  }
1633  /* create the real one */
1634  ksCreateSpoly(&(strat->P), strat->kNoetherTail(), strat->use_buckets,
1635  strat->tailRing, m1, m2, strat->R);
1636  if (!strat->use_buckets)
1637  strat->P.SetLength(strat->length_pLength);
1638  }
1639  else if (strat->P.p1 == NULL)
1640  {
1641  // for input polys, prepare reduction (buckets !)
1642  strat->P.SetLength(strat->length_pLength);
1643  strat->P.PrepareRed(strat->use_buckets);
1644  }
1645 
1646  // the s-poly
1647  if (!strat->P.IsNull())
1648  {
1649  // might be NULL from noether !!!
1650  if (TEST_OPT_PROT)
1651  message(strat->P.ecart+strat->P.GetpFDeg(),&olddeg,&reduc,strat, red_result);
1652  // reduce
1653  red_result = strat->red(&strat->P,strat);
1654  }
1655 
1656  // the reduced s-poly
1657  if (! strat->P.IsNull())
1658  {
1659  strat->P.GetP();
1660  // statistics
1661  if (TEST_OPT_PROT) PrintS("s");
1662  // normalization
1664  strat->P.pCleardenom();
1665  else
1666  strat->P.pNorm();
1667  // tailreduction
1668  strat->P.p = redtail(&(strat->P),strat->sl,strat);
1669  if (strat->P.p==NULL)
1670  {
1671  WerrorS("expoent overflow - wrong ordering");
1672  return(idInit(1,1));
1673  }
1674  // set ecart -- might have changed because of tail reductions
1675  if ((!strat->noTailReduction) && (!strat->honey))
1676  strat->initEcart(&strat->P);
1677  // cancel unit
1678  cancelunit(&strat->P);
1679  // for char 0, clear denominators
1680  if ((strat->P.p->next==NULL) /* i.e. cancelunit did something*/
1682  strat->P.pCleardenom();
1683 
1684  enterT(strat->P,strat);
1685  // build new pairs
1686  if (rField_is_Ring(currRing))
1687  superenterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1688  else
1689  enterpairs(strat->P.p,strat->sl,strat->P.ecart,0,strat, strat->tl);
1690  // put in S
1691  strat->enterS(strat->P,
1692  posInS(strat,strat->sl,strat->P.p, strat->P.ecart),
1693  strat, strat->tl);
1694  // apply hilbert criterion
1695  if (hilb!=NULL)
1696  {
1697  if (strat->homog==isHomog)
1698  khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
1699  else
1700  khCheckLocInhom(Q,w,hilb,hilbcount,strat);
1701  }
1702 
1703  // clear strat->P
1704  kDeleteLcm(&strat->P);
1705 
1706 #ifdef KDEBUG
1707  // make sure kTest_TS does not complain about strat->P
1708  memset(&strat->P,0,sizeof(strat->P));
1709 #endif
1710  }
1711  if (strat->kHEdgeFound)
1712  {
1713  if ((TEST_OPT_FINDET)
1714  || ((TEST_OPT_MULTBOUND) && (scMult0Int(strat->Shdl,NULL,strat->tailRing) < Kstd1_mu)))
1715  {
1716  // obachman: is this still used ???
1717  /*
1718  * stops computation if strat->kHEdgeFound and
1719  * - 27 (finiteDeterminacyTest)
1720  * or
1721  * - 23
1722  * (multBound)
1723  * && multiplicity of the ideal is smaller then a predefined number mu
1724  */
1725  while (strat->Ll >= 0) deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
1726  }
1727  }
1728  kTest_TS(strat);
1729  }
1730  /*- complete reduction of the standard basis------------------------ -*/
1731  if (TEST_OPT_REDSB) completeReduce(strat);
1732  else if (TEST_OPT_PROT) PrintLn();
1733  /*- release temp data------------------------------- -*/
1734  exitBuchMora(strat);
1735  /*- polynomials used for HECKE: HC, noether -*/
1736  if (TEST_OPT_FINDET)
1737  {
1738  if (strat->kHEdge!=NULL)
1739  Kstd1_mu=currRing->pFDeg(strat->kHEdge,currRing);
1740  else
1741  Kstd1_mu=-1;
1742  }
1743  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
1744  strat->update = TRUE; //???
1745  strat->lastAxis = 0; //???
1746  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
1747  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
1748  if ((TEST_OPT_PROT)||(TEST_OPT_DEBUG)) messageStat(hilbcount,strat);
1749 // if (TEST_OPT_WEIGHTM)
1750 // {
1751 // pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1752 // if (ecartWeights)
1753 // {
1754 // omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
1755 // ecartWeights=NULL;
1756 // }
1757 // }
1758  if(nCoeff_is_Z(currRing->cf))
1759  finalReduceByMon(strat);
1760  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
1761  SI_RESTORE_OPT1(save1);
1762  idTest(strat->Shdl);
1763  return (strat->Shdl);
1764 }
1765 
1766 poly kNF1 (ideal F,ideal Q,poly q, kStrategy strat, int lazyReduce)
1767 {
1768  assume(q!=NULL);
1769  assume(!(idIs0(F)&&(Q==NULL)));
1770 
1771 // lazy_reduce flags: can be combined by |
1772 //#define KSTD_NF_LAZY 1
1773  // do only a reduction of the leading term
1774 //#define KSTD_NF_ECART 2
1775  // only local: recude even with bad ecart
1776  poly p;
1777  int i;
1778  int j;
1779  int o;
1780  LObject h;
1781  BITSET save1;
1782  SI_SAVE_OPT1(save1);
1783 
1784  //if ((idIs0(F))&&(Q==NULL))
1785  // return pCopy(q); /*F=0*/
1786  //strat->ak = si_max(idRankFreeModule(F),pMaxComp(q));
1787  /*- creating temp data structures------------------- -*/
1788  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1789  strat->kNoether = pCopy((currRing->ppNoether));
1793  && (! TEST_V_DEG_STOP)
1794  && (0<Kstd1_deg)
1795  && ((!strat->kHEdgeFound)
1797  {
1798  pLmDelete(&strat->kNoether);
1799  strat->kNoether=pOne();
1800  pSetExp(strat->kNoether,1, Kstd1_deg+1);
1801  pSetm(strat->kNoether);
1802  strat->kHEdgeFound=TRUE;
1803  }
1804  initBuchMoraCrit(strat);
1806  initBuchMoraPosRing(strat);
1807  else
1808  initBuchMoraPos(strat);
1809  initMora(F,strat);
1810  strat->enterS = enterSMoraNF;
1811  /*- set T -*/
1812  strat->tl = -1;
1813  strat->tmax = setmaxT;
1814  strat->T = initT();
1815  strat->R = initR();
1816  strat->sevT = initsevT();
1817  /*- set S -*/
1818  strat->sl = -1;
1819  /*- init local data struct.-------------------------- -*/
1820  /*Shdl=*/initS(F,Q,strat);
1821  if ((strat->ak!=0)
1822  && (strat->kHEdgeFound))
1823  {
1824  if (strat->ak!=1)
1825  {
1826  pSetComp(strat->kNoether,1);
1827  pSetmComp(strat->kNoether);
1828  poly p=pHead(strat->kNoether);
1829  pSetComp(p,strat->ak);
1830  pSetmComp(p);
1831  p=pAdd(strat->kNoether,p);
1832  strat->kNoether=pNext(p);
1833  p_LmDelete(p,currRing);
1834  }
1835  }
1836  if ((lazyReduce & KSTD_NF_LAZY)==0)
1837  {
1838  for (i=strat->sl; i>=0; i--)
1839  pNorm(strat->S[i]);
1840  }
1841  /*- puts the elements of S also to T -*/
1842  for (i=0; i<=strat->sl; i++)
1843  {
1844  h.p = strat->S[i];
1845  h.ecart = strat->ecartS[i];
1846  if (strat->sevS[i] == 0) strat->sevS[i] = pGetShortExpVector(h.p);
1847  else assume(strat->sevS[i] == pGetShortExpVector(h.p));
1848  h.length = pLength(h.p);
1849  h.sev = strat->sevS[i];
1850  h.SetpFDeg();
1851  enterT(h,strat);
1852  }
1853 #ifdef KDEBUG
1854 // kDebugPrint(strat);
1855 #endif
1856  /*- compute------------------------------------------- -*/
1857  p = pCopy(q);
1858  deleteHC(&p,&o,&j,strat);
1859  kTest(strat);
1860  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
1861  if (BVERBOSE(23)) kDebugPrint(strat);
1863  {
1864  if (p!=NULL) p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
1865  }
1866  else
1867  {
1868  if (p!=NULL) p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
1869  }
1870  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
1871  {
1872  if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
1873  p = redtail(p,strat->sl,strat);
1874  }
1875  /*- release temp data------------------------------- -*/
1876  cleanT(strat);
1877  assume(strat->L==NULL); /*strat->L unsed */
1878  assume(strat->B==NULL); /*strat->B unused */
1879  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
1880  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
1881  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
1882  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
1883  omFree(strat->sevT);
1884  omFree(strat->S_2_R);
1885  omFree(strat->R);
1886 
1887  if ((Q!=NULL)&&(strat->fromQ!=NULL))
1888  {
1889  i=((IDELEMS(Q)+IDELEMS(F)+15)/16)*16;
1890  omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
1891  strat->fromQ=NULL;
1892  }
1893  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
1894  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
1895 // if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
1896 // {
1897 // pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
1898 // if (ecartWeights)
1899 // {
1900 // omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
1901 // ecartWeights=NULL;
1902 // }
1903 // }
1904  idDelete(&strat->Shdl);
1905  SI_RESTORE_OPT1(save1);
1906  if (TEST_OPT_PROT) PrintLn();
1907  return p;
1908 }
1909 
1910 ideal kNF1 (ideal F,ideal Q,ideal q, kStrategy strat, int lazyReduce)
1911 {
1912  assume(!idIs0(q));
1913  assume(!(idIs0(F)&&(Q==NULL)));
1914 
1915 // lazy_reduce flags: can be combined by |
1916 //#define KSTD_NF_LAZY 1
1917  // do only a reduction of the leading term
1918 //#define KSTD_NF_ECART 2
1919  // only local: recude even with bad ecart
1920  poly p;
1921  int i;
1922  int j;
1923  int o;
1924  LObject h;
1925  ideal res;
1926  BITSET save1;
1927  SI_SAVE_OPT1(save1);
1928 
1929  //if (idIs0(q)) return idInit(IDELEMS(q),si_max(q->rank,F->rank));
1930  //if ((idIs0(F))&&(Q==NULL))
1931  // return idCopy(q); /*F=0*/
1932  //strat->ak = si_max(idRankFreeModule(F),idRankFreeModule(q));
1933  /*- creating temp data structures------------------- -*/
1934  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
1935  strat->kNoether=pCopy((currRing->ppNoether));
1938  && (0<Kstd1_deg)
1939  && ((!strat->kHEdgeFound)
1941  {
1942  pLmDelete(&strat->kNoether);
1943  strat->kNoether=pOne();
1944  pSetExp(strat->kNoether,1, Kstd1_deg+1);
1945  pSetm(strat->kNoether);
1946  strat->kHEdgeFound=TRUE;
1947  }
1948  initBuchMoraCrit(strat);
1950  initBuchMoraPosRing(strat);
1951  else
1952  initBuchMoraPos(strat);
1953  initMora(F,strat);
1954  strat->enterS = enterSMoraNF;
1955  /*- set T -*/
1956  strat->tl = -1;
1957  strat->tmax = setmaxT;
1958  strat->T = initT();
1959  strat->R = initR();
1960  strat->sevT = initsevT();
1961  /*- set S -*/
1962  strat->sl = -1;
1963  /*- init local data struct.-------------------------- -*/
1964  /*Shdl=*/initS(F,Q,strat);
1965  if ((strat->ak!=0)
1966  && (strat->kHEdgeFound))
1967  {
1968  if (strat->ak!=1)
1969  {
1970  pSetComp(strat->kNoether,1);
1971  pSetmComp(strat->kNoether);
1972  poly p=pHead(strat->kNoether);
1973  pSetComp(p,strat->ak);
1974  pSetmComp(p);
1975  p=pAdd(strat->kNoether,p);
1976  strat->kNoether=pNext(p);
1977  p_LmDelete(p,currRing);
1978  }
1979  }
1980  if (TEST_OPT_INTSTRATEGY && ((lazyReduce & KSTD_NF_LAZY)==0))
1981  {
1982  for (i=strat->sl; i>=0; i--)
1983  pNorm(strat->S[i]);
1984  }
1985  /*- compute------------------------------------------- -*/
1986  res=idInit(IDELEMS(q),strat->ak);
1987  for (i=0; i<IDELEMS(q); i++)
1988  {
1989  if (q->m[i]!=NULL)
1990  {
1991  p = pCopy(q->m[i]);
1992  deleteHC(&p,&o,&j,strat);
1993  if (p!=NULL)
1994  {
1995  /*- puts the elements of S also to T -*/
1996  for (j=0; j<=strat->sl; j++)
1997  {
1998  h.p = strat->S[j];
1999  h.ecart = strat->ecartS[j];
2000  h.pLength = h.length = pLength(h.p);
2001  if (strat->sevS[j] == 0) strat->sevS[j] = pGetShortExpVector(h.p);
2002  else assume(strat->sevS[j] == pGetShortExpVector(h.p));
2003  h.sev = strat->sevS[j];
2004  h.SetpFDeg();
2006  enterT_strong(h,strat);
2007  else
2008  enterT(h,strat);
2009  }
2010  if (TEST_OPT_PROT) { PrintS("r"); mflush(); }
2012  {
2013  p = redMoraNFRing(p,strat, lazyReduce & KSTD_NF_ECART);
2014  }
2015  else
2016  p = redMoraNF(p,strat, lazyReduce & KSTD_NF_ECART);
2017  if ((p!=NULL)&&((lazyReduce & KSTD_NF_LAZY)==0))
2018  {
2019  if (TEST_OPT_PROT) { PrintS("t"); mflush(); }
2020  p = redtail(p,strat->sl,strat);
2021  }
2022  cleanT(strat);
2023  }
2024  res->m[i]=p;
2025  }
2026  //else
2027  // res->m[i]=NULL;
2028  }
2029  /*- release temp data------------------------------- -*/
2030  assume(strat->L==NULL); /*strat->L unsed */
2031  assume(strat->B==NULL); /*strat->B unused */
2032  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
2033  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
2034  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
2035  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
2036  omFree(strat->sevT);
2037  omFree(strat->S_2_R);
2038  omFree(strat->R);
2039  if ((Q!=NULL)&&(strat->fromQ!=NULL))
2040  {
2042  omFreeSize((ADDRESS)strat->fromQ,i*sizeof(int));
2043  strat->fromQ=NULL;
2044  }
2045  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
2046  if (strat->kNoether!=NULL) pLmDelete(&strat->kNoether);
2047 // if ((TEST_OPT_WEIGHTM)&&(F!=NULL))
2048 // {
2049 // pFDeg=strat->pOrigFDeg;
2050 // pLDeg=strat->pOrigLDeg;
2051 // if (ecartWeights)
2052 // {
2053 // omFreeSize((ADDRESS *)&ecartWeights,((currRing->N)+1)*sizeof(short));
2054 // ecartWeights=NULL;
2055 // }
2056 // }
2057  idDelete(&strat->Shdl);
2058  SI_RESTORE_OPT1(save1);
2059  if (TEST_OPT_PROT) PrintLn();
2060  return res;
2061 }
2062 
2064 
2065 long kModDeg(poly p, ring r)
2066 {
2067  long o=p_WDegree(p, r);
2068  long i=__p_GetComp(p, r);
2069  if (i==0) return o;
2070  //assume((i>0) && (i<=kModW->length()));
2071  if (i<=kModW->length())
2072  return o+(*kModW)[i-1];
2073  return o;
2074 }
2075 long kHomModDeg(poly p, ring r)
2076 {
2077  int i;
2078  long j=0;
2079 
2080  for (i=r->N;i>0;i--)
2081  j+=p_GetExp(p,i,r)*(*kHomW)[i-1];
2082  if (kModW == NULL) return j;
2083  i = __p_GetComp(p,r);
2084  if (i==0) return j;
2085  return j+(*kModW)[i-1];
2086 }
2087 
2088 ideal kStd(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
2089  int newIdeal, intvec *vw, s_poly_proc_t sp)
2090 {
2091  if(idIs0(F))
2092  return idInit(1,F->rank);
2093 
2094 #ifdef HAVE_SHIFTBBA
2095  if(rIsLPRing(currRing)) return freegb(F);
2096 #endif
2097 
2098  ideal r;
2099  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2100  BOOLEAN delete_w=(w==NULL);
2101  kStrategy strat=new skStrategy;
2102 
2103  strat->s_poly=sp;
2104  if(!TEST_OPT_RETURN_SB)
2105  strat->syzComp = syzComp;
2106  if (TEST_OPT_SB_1
2107  &&(!rField_is_Ring(currRing))
2108  )
2109  strat->newIdeal = newIdeal;
2111  strat->LazyPass=20;
2112  else
2113  strat->LazyPass=2;
2114  strat->LazyDegree = 1;
2115  strat->ak = id_RankFreeModule(F,currRing);
2116  strat->kModW=kModW=NULL;
2117  strat->kHomW=kHomW=NULL;
2118  if (vw != NULL)
2119  {
2120  currRing->pLexOrder=FALSE;
2121  strat->kHomW=kHomW=vw;
2122  strat->pOrigFDeg = currRing->pFDeg;
2123  strat->pOrigLDeg = currRing->pLDeg;
2125  toReset = TRUE;
2126  }
2127  if (h==testHomog)
2128  {
2129  if (strat->ak == 0)
2130  {
2131  h = (tHomog)idHomIdeal(F,Q);
2132  w=NULL;
2133  }
2134  else if (!TEST_OPT_DEGBOUND)
2135  {
2136  if (w!=NULL)
2137  h = (tHomog)idHomModule(F,Q,w);
2138  else
2139  h = (tHomog)idHomIdeal(F,Q);
2140  }
2141  }
2142  currRing->pLexOrder=b;
2143  if (h==isHomog)
2144  {
2145  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2146  {
2147  strat->kModW = kModW = *w;
2148  if (vw == NULL)
2149  {
2150  strat->pOrigFDeg = currRing->pFDeg;
2151  strat->pOrigLDeg = currRing->pLDeg;
2153  toReset = TRUE;
2154  }
2155  }
2156  currRing->pLexOrder = TRUE;
2157  if (hilb==NULL) strat->LazyPass*=2;
2158  }
2159  strat->homog=h;
2160 #ifdef KDEBUG
2161  idTest(F);
2162  if (Q!=NULL) idTest(Q);
2163 #endif
2164 #ifdef HAVE_PLURAL
2165  if (rIsPluralRing(currRing))
2166  {
2167  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2168  strat->no_prod_crit = ! bIsSCA;
2169  if (w!=NULL)
2170  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2171  else
2172  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2173  }
2174  else
2175 #endif
2176  {
2177  #if PRE_INTEGER_CHECK
2178  //the preinteger check strategy is not for modules
2179  if(nCoeff_is_Z(currRing->cf) && strat->ak <= 0)
2180  {
2181  ideal FCopy = idCopy(F);
2182  poly pFmon = preIntegerCheck(FCopy, Q);
2183  if(pFmon != NULL)
2184  {
2185  idInsertPoly(FCopy, pFmon);
2186  strat->kModW=kModW=NULL;
2187  if (h==testHomog)
2188  {
2189  if (strat->ak == 0)
2190  {
2191  h = (tHomog)idHomIdeal(FCopy,Q);
2192  w=NULL;
2193  }
2194  else if (!TEST_OPT_DEGBOUND)
2195  {
2196  if (w!=NULL)
2197  h = (tHomog)idHomModule(FCopy,Q,w);
2198  else
2199  h = (tHomog)idHomIdeal(FCopy,Q);
2200  }
2201  }
2202  currRing->pLexOrder=b;
2203  if (h==isHomog)
2204  {
2205  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2206  {
2207  strat->kModW = kModW = *w;
2208  if (vw == NULL)
2209  {
2210  strat->pOrigFDeg = currRing->pFDeg;
2211  strat->pOrigLDeg = currRing->pLDeg;
2213  toReset = TRUE;
2214  }
2215  }
2216  currRing->pLexOrder = TRUE;
2217  if (hilb==NULL) strat->LazyPass*=2;
2218  }
2219  strat->homog=h;
2220  }
2221  omTestMemory(1);
2222  if(w == NULL)
2223  {
2225  r=mora(FCopy,Q,NULL,hilb,strat);
2226  else
2227  r=bba(FCopy,Q,NULL,hilb,strat);
2228  }
2229  else
2230  {
2232  r=mora(FCopy,Q,*w,hilb,strat);
2233  else
2234  r=bba(FCopy,Q,*w,hilb,strat);
2235  }
2236  idDelete(&FCopy);
2237  }
2238  else
2239  #endif
2240  {
2241  if(w==NULL)
2242  {
2244  r=mora(F,Q,NULL,hilb,strat);
2245  else
2246  r=bba(F,Q,NULL,hilb,strat);
2247  }
2248  else
2249  {
2251  r=mora(F,Q,*w,hilb,strat);
2252  else
2253  r=bba(F,Q,*w,hilb,strat);
2254  }
2255  }
2256  }
2257 #ifdef KDEBUG
2258  idTest(r);
2259 #endif
2260  if (toReset)
2261  {
2262  kModW = NULL;
2263  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2264  }
2265  currRing->pLexOrder = b;
2266 //Print("%d reductions canceled \n",strat->cel);
2267  HCord=strat->HCord;
2268  delete(strat);
2269  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2270  return r;
2271 }
2272 
2273 ideal kSba(ideal F, ideal Q, tHomog h,intvec ** w, int sbaOrder, int arri, intvec *hilb,int syzComp,
2274  int newIdeal, intvec *vw)
2275 {
2276  if(idIs0(F))
2277  return idInit(1,F->rank);
2278  if(!rField_is_Ring(currRing))
2279  {
2280  ideal r;
2281  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2282  BOOLEAN delete_w=(w==NULL);
2283  kStrategy strat=new skStrategy;
2284  strat->sbaOrder = sbaOrder;
2285  if (arri!=0)
2286  {
2287  strat->rewCrit1 = arriRewDummy;
2288  strat->rewCrit2 = arriRewCriterion;
2289  strat->rewCrit3 = arriRewCriterionPre;
2290  }
2291  else
2292  {
2293  strat->rewCrit1 = faugereRewCriterion;
2294  strat->rewCrit2 = faugereRewCriterion;
2295  strat->rewCrit3 = faugereRewCriterion;
2296  }
2297 
2298  if(!TEST_OPT_RETURN_SB)
2299  strat->syzComp = syzComp;
2300  if (TEST_OPT_SB_1)
2301  //if(!rField_is_Ring(currRing)) // always true here
2302  strat->newIdeal = newIdeal;
2304  strat->LazyPass=20;
2305  else
2306  strat->LazyPass=2;
2307  strat->LazyDegree = 1;
2309  strat->chainCrit=chainCritNormal;
2311  strat->ak = id_RankFreeModule(F,currRing);
2312  strat->kModW=kModW=NULL;
2313  strat->kHomW=kHomW=NULL;
2314  if (vw != NULL)
2315  {
2316  currRing->pLexOrder=FALSE;
2317  strat->kHomW=kHomW=vw;
2318  strat->pOrigFDeg = currRing->pFDeg;
2319  strat->pOrigLDeg = currRing->pLDeg;
2321  toReset = TRUE;
2322  }
2323  if (h==testHomog)
2324  {
2325  if (strat->ak == 0)
2326  {
2327  h = (tHomog)idHomIdeal(F,Q);
2328  w=NULL;
2329  }
2330  else if (!TEST_OPT_DEGBOUND)
2331  {
2332  if (w!=NULL)
2333  h = (tHomog)idHomModule(F,Q,w);
2334  else
2335  h = (tHomog)idHomIdeal(F,Q);
2336  }
2337  }
2338  currRing->pLexOrder=b;
2339  if (h==isHomog)
2340  {
2341  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2342  {
2343  strat->kModW = kModW = *w;
2344  if (vw == NULL)
2345  {
2346  strat->pOrigFDeg = currRing->pFDeg;
2347  strat->pOrigLDeg = currRing->pLDeg;
2349  toReset = TRUE;
2350  }
2351  }
2352  currRing->pLexOrder = TRUE;
2353  if (hilb==NULL) strat->LazyPass*=2;
2354  }
2355  strat->homog=h;
2356  #ifdef KDEBUG
2357  idTest(F);
2358  if(Q != NULL)
2359  idTest(Q);
2360  #endif
2361  #ifdef HAVE_PLURAL
2362  if (rIsPluralRing(currRing))
2363  {
2364  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2365  strat->no_prod_crit = ! bIsSCA;
2366  if (w!=NULL)
2367  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2368  else
2369  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2370  }
2371  else
2372  #endif
2373  {
2375  {
2376  if (w!=NULL)
2377  r=mora(F,Q,*w,hilb,strat);
2378  else
2379  r=mora(F,Q,NULL,hilb,strat);
2380  }
2381  else
2382  {
2383  strat->sigdrop = FALSE;
2384  if (w!=NULL)
2385  r=sba(F,Q,*w,hilb,strat);
2386  else
2387  r=sba(F,Q,NULL,hilb,strat);
2388  }
2389  }
2390  #ifdef KDEBUG
2391  idTest(r);
2392  #endif
2393  if (toReset)
2394  {
2395  kModW = NULL;
2396  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2397  }
2398  currRing->pLexOrder = b;
2399  //Print("%d reductions canceled \n",strat->cel);
2400  HCord=strat->HCord;
2401  //delete(strat);
2402  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2403  return r;
2404  }
2405  else
2406  {
2407  //--------------------------RING CASE-------------------------
2408  assume(sbaOrder == 1);
2409  assume(arri == 0);
2410  ideal r;
2411  r = idCopy(F);
2412  int sbaEnterS = -1;
2413  bool sigdrop = TRUE;
2414  //This is how we set the SBA algorithm;
2415  int totalsbaruns = 1,blockedreductions = 20,blockred = 0,loops = 0;
2416  while(sigdrop && (loops < totalsbaruns || totalsbaruns == -1)
2417  && (blockred <= blockedreductions))
2418  {
2419  loops++;
2420  if(loops == 1)
2421  sigdrop = FALSE;
2422  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2423  BOOLEAN delete_w=(w==NULL);
2424  kStrategy strat=new skStrategy;
2425  strat->sbaEnterS = sbaEnterS;
2426  strat->sigdrop = sigdrop;
2427  #if 0
2428  strat->blockred = blockred;
2429  #else
2430  strat->blockred = 0;
2431  #endif
2432  strat->blockredmax = blockedreductions;
2433  //printf("\nsbaEnterS beginning = %i\n",strat->sbaEnterS);
2434  //printf("\nsigdrop beginning = %i\n",strat->sigdrop);
2435  strat->sbaOrder = sbaOrder;
2436  if (arri!=0)
2437  {
2438  strat->rewCrit1 = arriRewDummy;
2439  strat->rewCrit2 = arriRewCriterion;
2440  strat->rewCrit3 = arriRewCriterionPre;
2441  }
2442  else
2443  {
2444  strat->rewCrit1 = faugereRewCriterion;
2445  strat->rewCrit2 = faugereRewCriterion;
2446  strat->rewCrit3 = faugereRewCriterion;
2447  }
2448 
2449  if(!TEST_OPT_RETURN_SB)
2450  strat->syzComp = syzComp;
2451  if (TEST_OPT_SB_1)
2452  if(!rField_is_Ring(currRing))
2453  strat->newIdeal = newIdeal;
2455  strat->LazyPass=20;
2456  else
2457  strat->LazyPass=2;
2458  strat->LazyDegree = 1;
2460  strat->chainCrit=chainCritNormal;
2462  strat->ak = id_RankFreeModule(F,currRing);
2463  strat->kModW=kModW=NULL;
2464  strat->kHomW=kHomW=NULL;
2465  if (vw != NULL)
2466  {
2467  currRing->pLexOrder=FALSE;
2468  strat->kHomW=kHomW=vw;
2469  strat->pOrigFDeg = currRing->pFDeg;
2470  strat->pOrigLDeg = currRing->pLDeg;
2472  toReset = TRUE;
2473  }
2474  if (h==testHomog)
2475  {
2476  if (strat->ak == 0)
2477  {
2478  h = (tHomog)idHomIdeal(F,Q);
2479  w=NULL;
2480  }
2481  else if (!TEST_OPT_DEGBOUND)
2482  {
2483  if (w!=NULL)
2484  h = (tHomog)idHomModule(F,Q,w);
2485  else
2486  h = (tHomog)idHomIdeal(F,Q);
2487  }
2488  }
2489  currRing->pLexOrder=b;
2490  if (h==isHomog)
2491  {
2492  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2493  {
2494  strat->kModW = kModW = *w;
2495  if (vw == NULL)
2496  {
2497  strat->pOrigFDeg = currRing->pFDeg;
2498  strat->pOrigLDeg = currRing->pLDeg;
2500  toReset = TRUE;
2501  }
2502  }
2503  currRing->pLexOrder = TRUE;
2504  if (hilb==NULL) strat->LazyPass*=2;
2505  }
2506  strat->homog=h;
2507  #ifdef KDEBUG
2508  idTest(F);
2509  if(Q != NULL)
2510  idTest(Q);
2511  #endif
2512  #ifdef HAVE_PLURAL
2513  if (rIsPluralRing(currRing))
2514  {
2515  const BOOLEAN bIsSCA = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
2516  strat->no_prod_crit = ! bIsSCA;
2517  if (w!=NULL)
2518  r = nc_GB(F, Q, *w, hilb, strat, currRing);
2519  else
2520  r = nc_GB(F, Q, NULL, hilb, strat, currRing);
2521  }
2522  else
2523  #endif
2524  {
2526  {
2527  if (w!=NULL)
2528  r=mora(F,Q,*w,hilb,strat);
2529  else
2530  r=mora(F,Q,NULL,hilb,strat);
2531  }
2532  else
2533  {
2534  if (w!=NULL)
2535  r=sba(r,Q,*w,hilb,strat);
2536  else
2537  {
2538  r=sba(r,Q,NULL,hilb,strat);
2539  }
2540  }
2541  }
2542  #ifdef KDEBUG
2543  idTest(r);
2544  #endif
2545  if (toReset)
2546  {
2547  kModW = NULL;
2548  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2549  }
2550  currRing->pLexOrder = b;
2551  //Print("%d reductions canceled \n",strat->cel);
2552  HCord=strat->HCord;
2553  sigdrop = strat->sigdrop;
2554  sbaEnterS = strat->sbaEnterS;
2555  blockred = strat->blockred;
2556  delete(strat);
2557  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2558  }
2559  // Go to std
2560  if(sigdrop || blockred > blockedreductions)
2561  {
2562  r = kStd(r, Q, h, w, hilb, syzComp, newIdeal, vw);
2563  }
2564  return r;
2565  }
2566 }
2567 
2568 #ifdef HAVE_SHIFTBBA
2569 ideal kStdShift(ideal F, ideal Q, tHomog h,intvec ** w, intvec *hilb,int syzComp,
2570  int newIdeal, intvec *vw)
2571 {
2572  ideal r;
2573  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2574  BOOLEAN delete_w=(w==NULL);
2575  kStrategy strat=new skStrategy;
2576  intvec* temp_w=NULL;
2577 
2578  if(!TEST_OPT_RETURN_SB)
2579  strat->syzComp = syzComp;
2580  if (TEST_OPT_SB_1)
2581  if(!rField_is_Ring(currRing))
2582  strat->newIdeal = newIdeal;
2584  strat->LazyPass=20;
2585  else
2586  strat->LazyPass=2;
2587  strat->LazyDegree = 1;
2588  strat->ak = id_RankFreeModule(F,currRing);
2589  strat->kModW=kModW=NULL;
2590  strat->kHomW=kHomW=NULL;
2591  if (vw != NULL)
2592  {
2593  currRing->pLexOrder=FALSE;
2594  strat->kHomW=kHomW=vw;
2595  strat->pOrigFDeg = currRing->pFDeg;
2596  strat->pOrigLDeg = currRing->pLDeg;
2598  toReset = TRUE;
2599  }
2600  if (h==testHomog)
2601  {
2602  if (strat->ak == 0)
2603  {
2604  h = (tHomog)idHomIdeal(F,Q);
2605  w=NULL;
2606  }
2607  else if (!TEST_OPT_DEGBOUND)
2608  {
2609  if (w!=NULL)
2610  h = (tHomog)idHomModule(F,Q,w);
2611  else
2612  h = (tHomog)idHomIdeal(F,Q);
2613  }
2614  }
2615  currRing->pLexOrder=b;
2616  if (h==isHomog)
2617  {
2618  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2619  {
2620  strat->kModW = kModW = *w;
2621  if (vw == NULL)
2622  {
2623  strat->pOrigFDeg = currRing->pFDeg;
2624  strat->pOrigLDeg = currRing->pLDeg;
2626  toReset = TRUE;
2627  }
2628  }
2629  currRing->pLexOrder = TRUE;
2630  if (hilb==NULL) strat->LazyPass*=2;
2631  }
2632  strat->homog=h;
2633 #ifdef KDEBUG
2634  idTest(F);
2635 #endif
2637  {
2638  /* error: no local ord yet with shifts */
2639  WerrorS("No local ordering possible for shift algebra");
2640  return(NULL);
2641  }
2642  else
2643  {
2644  /* global ordering */
2645  if (w!=NULL)
2646  r=bbaShift(F,Q,*w,hilb,strat);
2647  else
2648  r=bbaShift(F,Q,NULL,hilb,strat);
2649  }
2650 #ifdef KDEBUG
2651  idTest(r);
2652 #endif
2653  if (toReset)
2654  {
2655  kModW = NULL;
2656  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2657  }
2658  currRing->pLexOrder = b;
2659 //Print("%d reductions canceled \n",strat->cel);
2660  HCord=strat->HCord;
2661  delete(strat);
2662  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
2663  return r;
2664 }
2665 #endif
2666 
2667 //##############################################################
2668 //##############################################################
2669 //##############################################################
2670 //##############################################################
2671 //##############################################################
2672 
2673 ideal kMin_std(ideal F, ideal Q, tHomog h,intvec ** w, ideal &M, intvec *hilb,
2674  int syzComp, int reduced)
2675 {
2676  if(idIs0(F))
2677  {
2678  M=idInit(1,F->rank);
2679  return idInit(1,F->rank);
2680  }
2682  {
2683  ideal sb;
2684  sb = kStd(F, Q, h, w, hilb);
2685  idSkipZeroes(sb);
2686  if(IDELEMS(sb) <= IDELEMS(F))
2687  {
2688  M = idCopy(sb);
2689  idSkipZeroes(M);
2690  return(sb);
2691  }
2692  else
2693  {
2694  M = idCopy(F);
2695  idSkipZeroes(M);
2696  return(sb);
2697  }
2698  }
2699  ideal r=NULL;
2700  int Kstd1_OldDeg = Kstd1_deg,i;
2701  intvec* temp_w=NULL;
2702  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
2703  BOOLEAN delete_w=(w==NULL);
2704  BOOLEAN oldDegBound=TEST_OPT_DEGBOUND;
2705  kStrategy strat=new skStrategy;
2706 
2707  if(!TEST_OPT_RETURN_SB)
2708  strat->syzComp = syzComp;
2710  strat->LazyPass=20;
2711  else
2712  strat->LazyPass=2;
2713  strat->LazyDegree = 1;
2714  strat->minim=(reduced % 2)+1;
2715  strat->ak = id_RankFreeModule(F,currRing);
2716  if (delete_w)
2717  {
2718  temp_w=new intvec((strat->ak)+1);
2719  w = &temp_w;
2720  }
2721  if (h==testHomog)
2722  {
2723  if (strat->ak == 0)
2724  {
2725  h = (tHomog)idHomIdeal(F,Q);
2726  w=NULL;
2727  }
2728  else
2729  {
2730  h = (tHomog)idHomModule(F,Q,w);
2731  }
2732  }
2733  if (h==isHomog)
2734  {
2735  if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
2736  {
2737  kModW = *w;
2738  strat->kModW = *w;
2739  assume(currRing->pFDeg != NULL && currRing->pLDeg != NULL);
2740  strat->pOrigFDeg = currRing->pFDeg;
2741  strat->pOrigLDeg = currRing->pLDeg;
2743 
2744  toReset = TRUE;
2745  if (reduced>1)
2746  {
2747  Kstd1_OldDeg=Kstd1_deg;
2748  Kstd1_deg = -1;
2749  for (i=IDELEMS(F)-1;i>=0;i--)
2750  {
2751  if ((F->m[i]!=NULL) && (currRing->pFDeg(F->m[i],currRing)>=Kstd1_deg))
2752  Kstd1_deg = currRing->pFDeg(F->m[i],currRing)+1;
2753  }
2754  }
2755  }
2756  currRing->pLexOrder = TRUE;
2757  strat->LazyPass*=2;
2758  }
2759  strat->homog=h;
2761  {
2762  if (w!=NULL)
2763  r=mora(F,Q,*w,hilb,strat);
2764  else
2765  r=mora(F,Q,NULL,hilb,strat);
2766  }
2767  else
2768  {
2769  if (w!=NULL)
2770  r=bba(F,Q,*w,hilb,strat);
2771  else
2772  r=bba(F,Q,NULL,hilb,strat);
2773  }
2774 #ifdef KDEBUG
2775  {
2776  int i;
2777  for (i=IDELEMS(r)-1; i>=0; i--) pTest(r->m[i]);
2778  }
2779 #endif
2780  idSkipZeroes(r);
2781  if (toReset)
2782  {
2783  pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
2784  kModW = NULL;
2785  }
2786  currRing->pLexOrder = b;
2787  HCord=strat->HCord;
2788  if ((delete_w)&&(temp_w!=NULL)) delete temp_w;
2789  if ((IDELEMS(r)==1) && (r->m[0]!=NULL) && pIsConstant(r->m[0]) && (strat->ak==0))
2790  {
2791  M=idInit(1,F->rank);
2792  M->m[0]=pOne();
2793  //if (strat->ak!=0) { pSetComp(M->m[0],strat->ak); pSetmComp(M->m[0]); }
2794  if (strat->M!=NULL) idDelete(&strat->M);
2795  }
2796  else if (strat->M==NULL)
2797  {
2798  M=idInit(1,F->rank);
2799  WarnS("no minimal generating set computed");
2800  }
2801  else
2802  {
2803  idSkipZeroes(strat->M);
2804  M=strat->M;
2805  }
2806  delete(strat);
2807  if (reduced>2)
2808  {
2809  Kstd1_deg=Kstd1_OldDeg;
2810  if (!oldDegBound)
2812  }
2813  else
2814  {
2815  if (IDELEMS(M)>IDELEMS(r)) {
2816  idDelete(&M);
2817  M=idCopy(r); }
2818  }
2819  return r;
2820 }
2821 
2822 poly kNF(ideal F, ideal Q, poly p,int syzComp, int lazyReduce)
2823 {
2824  if (p==NULL)
2825  return NULL;
2826 
2827  poly pp = p;
2828 
2829 #ifdef HAVE_PLURAL
2830  if(rIsSCA(currRing))
2831  {
2832  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2833  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2834  pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
2835 
2836  if(Q == currRing->qideal)
2837  Q = SCAQuotient(currRing);
2838  }
2839 #endif
2840 
2841  if ((idIs0(F))&&(Q==NULL))
2842  {
2843 #ifdef HAVE_PLURAL
2844  if(p != pp)
2845  return pp;
2846 #endif
2847  return pCopy(p); /*F+Q=0*/
2848  }
2849 
2850  kStrategy strat=new skStrategy;
2851  strat->syzComp = syzComp;
2852  strat->ak = si_max(id_RankFreeModule(F,currRing),pMaxComp(p));
2853  poly res;
2854 
2856  {
2857 #ifdef HAVE_SHIFTBBA
2858  if (currRing->isLPring)
2859  {
2860  WerrorS("No local ordering possible for shift algebra");
2861  return(NULL);
2862  }
2863 #endif
2864  res=kNF1(F,Q,pp,strat,lazyReduce);
2865  }
2866  else
2867  res=kNF2(F,Q,pp,strat,lazyReduce);
2868  delete(strat);
2869 
2870 #ifdef HAVE_PLURAL
2871  if(pp != p)
2872  p_Delete(&pp, currRing);
2873 #endif
2874  return res;
2875 }
2876 
2877 poly kNFBound(ideal F, ideal Q, poly p,int bound,int syzComp, int lazyReduce)
2878 {
2879  if (p==NULL)
2880  return NULL;
2881 
2882  poly pp = p;
2883 
2884 #ifdef HAVE_PLURAL
2885  if(rIsSCA(currRing))
2886  {
2887  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2888  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2889  pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
2890 
2891  if(Q == currRing->qideal)
2892  Q = SCAQuotient(currRing);
2893  }
2894 #endif
2895 
2896  if ((idIs0(F))&&(Q==NULL))
2897  {
2898 #ifdef HAVE_PLURAL
2899  if(p != pp)
2900  return pp;
2901 #endif
2902  return pCopy(p); /*F+Q=0*/
2903  }
2904 
2905  kStrategy strat=new skStrategy;
2906  strat->syzComp = syzComp;
2907  strat->ak = si_max(id_RankFreeModule(F,currRing),pMaxComp(p));
2908  poly res;
2909  res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
2910  delete(strat);
2911 
2912 #ifdef HAVE_PLURAL
2913  if(pp != p)
2914  p_Delete(&pp, currRing);
2915 #endif
2916  return res;
2917 }
2918 
2919 ideal kNF(ideal F, ideal Q, ideal p,int syzComp,int lazyReduce)
2920 {
2921  ideal res;
2922  if (TEST_OPT_PROT)
2923  {
2924  Print("(S:%d)",IDELEMS(p));mflush();
2925  }
2926  if (idIs0(p))
2927  return idInit(IDELEMS(p),si_max(p->rank,F->rank));
2928 
2929  ideal pp = p;
2930 #ifdef HAVE_PLURAL
2931  if(rIsSCA(currRing))
2932  {
2933  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2934  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2935  pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
2936 
2937  if(Q == currRing->qideal)
2938  Q = SCAQuotient(currRing);
2939  }
2940 #endif
2941 
2942  if ((idIs0(F))&&(Q==NULL))
2943  {
2944 #ifdef HAVE_PLURAL
2945  if(p != pp)
2946  return pp;
2947 #endif
2948  return idCopy(p); /*F+Q=0*/
2949  }
2950 
2951  kStrategy strat=new skStrategy;
2952  strat->syzComp = syzComp;
2954  if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
2955  {
2956  strat->ak = si_max(strat->ak,(int)F->rank);
2957  }
2958 
2960  {
2961 #ifdef HAVE_SHIFTBBA
2962  if (currRing->isLPring)
2963  {
2964  WerrorS("No local ordering possible for shift algebra");
2965  return(NULL);
2966  }
2967 #endif
2968  res=kNF1(F,Q,pp,strat,lazyReduce);
2969  }
2970  else
2971  res=kNF2(F,Q,pp,strat,lazyReduce);
2972  delete(strat);
2973 
2974 #ifdef HAVE_PLURAL
2975  if(pp != p)
2976  id_Delete(&pp, currRing);
2977 #endif
2978 
2979  return res;
2980 }
2981 
2982 ideal kNFBound(ideal F, ideal Q, ideal p,int bound,int syzComp,int lazyReduce)
2983 {
2984  ideal res;
2985  if (TEST_OPT_PROT)
2986  {
2987  Print("(S:%d)",IDELEMS(p));mflush();
2988  }
2989  if (idIs0(p))
2990  return idInit(IDELEMS(p),si_max(p->rank,F->rank));
2991 
2992  ideal pp = p;
2993 #ifdef HAVE_PLURAL
2994  if(rIsSCA(currRing))
2995  {
2996  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
2997  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
2998  pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
2999 
3000  if(Q == currRing->qideal)
3001  Q = SCAQuotient(currRing);
3002  }
3003 #endif
3004 
3005  if ((idIs0(F))&&(Q==NULL))
3006  {
3007 #ifdef HAVE_PLURAL
3008  if(p != pp)
3009  return pp;
3010 #endif
3011  return idCopy(p); /*F+Q=0*/
3012  }
3013 
3014  kStrategy strat=new skStrategy;
3015  strat->syzComp = syzComp;
3017  if (strat->ak>0) // only for module case, see Tst/Short/bug_reduce.tst
3018  {
3019  strat->ak = si_max(strat->ak,(int)F->rank);
3020  }
3021 
3022  res=kNF2Bound(F,Q,pp,bound,strat,lazyReduce);
3023  delete(strat);
3024 
3025 #ifdef HAVE_PLURAL
3026  if(pp != p)
3027  id_Delete(&pp, currRing);
3028 #endif
3029 
3030  return res;
3031 }
3032 
3033 poly k_NF (ideal F, ideal Q, poly p,int syzComp, int lazyReduce, const ring _currRing)
3034 {
3035  const ring save = currRing;
3036  if( currRing != _currRing ) rChangeCurrRing(_currRing);
3037  poly ret = kNF(F, Q, p, syzComp, lazyReduce);
3038  if( currRing != save ) rChangeCurrRing(save);
3039  return ret;
3040 }
3041 
3042 /*2
3043 *interreduces F
3044 */
3045 // old version
3046 ideal kInterRedOld (ideal F, ideal Q)
3047 {
3048  int j;
3049  kStrategy strat = new skStrategy;
3050 
3051  ideal tempF = F;
3052  ideal tempQ = Q;
3053 
3054 #ifdef HAVE_PLURAL
3055  if(rIsSCA(currRing))
3056  {
3057  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
3058  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
3059  tempF = id_KillSquares(F, m_iFirstAltVar, m_iLastAltVar, currRing);
3060 
3061  // this should be done on the upper level!!! :
3062  // tempQ = SCAQuotient(currRing);
3063 
3064  if(Q == currRing->qideal)
3065  tempQ = SCAQuotient(currRing);
3066  }
3067 #endif
3068 
3069 // if (TEST_OPT_PROT)
3070 // {
3071 // writeTime("start InterRed:");
3072 // mflush();
3073 // }
3074  //strat->syzComp = 0;
3075  strat->kHEdgeFound = (currRing->ppNoether) != NULL;
3076  strat->kNoether=pCopy((currRing->ppNoether));
3077  strat->ak = id_RankFreeModule(tempF,currRing);
3078  initBuchMoraCrit(strat);
3079  strat->NotUsedAxis = (BOOLEAN *)omAlloc(((currRing->N)+1)*sizeof(BOOLEAN));
3080  for (j=(currRing->N); j>0; j--) strat->NotUsedAxis[j] = TRUE;
3081  strat->enterS = enterSBba;
3082  strat->posInT = posInT17;
3083  strat->initEcart = initEcartNormal;
3084  strat->sl = -1;
3085  strat->tl = -1;
3086  strat->tmax = setmaxT;
3087  strat->T = initT();
3088  strat->R = initR();
3089  strat->sevT = initsevT();
3091  initS(tempF, tempQ, strat);
3092  if (TEST_OPT_REDSB)
3093  strat->noTailReduction=FALSE;
3094  updateS(TRUE,strat);
3096  completeReduce(strat);
3097  //else if (TEST_OPT_PROT) PrintLn();
3098  cleanT(strat);
3099  if (strat->kHEdge!=NULL) pLmFree(&strat->kHEdge);
3100  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
3101  omFreeSize((ADDRESS)strat->ecartS,IDELEMS(strat->Shdl)*sizeof(int));
3102  omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
3103  omFreeSize((ADDRESS)strat->NotUsedAxis,((currRing->N)+1)*sizeof(BOOLEAN));
3104  omfree(strat->sevT);
3105  omfree(strat->S_2_R);
3106  omfree(strat->R);
3107 
3108  if (strat->fromQ)
3109  {
3110  for (j=IDELEMS(strat->Shdl)-1;j>=0;j--)
3111  {
3112  if(strat->fromQ[j]) pDelete(&strat->Shdl->m[j]);
3113  }
3114  omFreeSize((ADDRESS)strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
3115  }
3116 // if (TEST_OPT_PROT)
3117 // {
3118 // writeTime("end Interred:");
3119 // mflush();
3120 // }
3121  ideal shdl=strat->Shdl;
3122  idSkipZeroes(shdl);
3123  if (strat->fromQ)
3124  {
3125  strat->fromQ=NULL;
3126  ideal res=kInterRed(shdl,NULL);
3127  idDelete(&shdl);
3128  shdl=res;
3129  }
3130  delete(strat);
3131 #ifdef HAVE_PLURAL
3132  if( tempF != F )
3133  id_Delete( &tempF, currRing);
3134 #endif
3135  return shdl;
3136 }
3137 // new version
3138 ideal kInterRedBba (ideal F, ideal Q, int &need_retry)
3139 {
3140  need_retry=0;
3141  int red_result = 1;
3142  int olddeg,reduc;
3143  BOOLEAN withT = FALSE;
3144  // BOOLEAN toReset=FALSE;
3145  kStrategy strat=new skStrategy;
3146  tHomog h;
3147 
3149  strat->LazyPass=20;
3150  else
3151  strat->LazyPass=2;
3152  strat->LazyDegree = 1;
3153  strat->ak = id_RankFreeModule(F,currRing);
3154  strat->syzComp = strat->ak;
3155  strat->kModW=kModW=NULL;
3156  strat->kHomW=kHomW=NULL;
3157  if (strat->ak == 0)
3158  {
3159  h = (tHomog)idHomIdeal(F,Q);
3160  }
3161  else if (!TEST_OPT_DEGBOUND)
3162  {
3163  h = (tHomog)idHomIdeal(F,Q);
3164  }
3165  else
3166  h = isNotHomog;
3167  if (h==isHomog)
3168  {
3169  strat->LazyPass*=2;
3170  }
3171  strat->homog=h;
3172 #ifdef KDEBUG
3173  idTest(F);
3174 #endif
3175 
3176  initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
3178  initBuchMoraPosRing(strat);
3179  else
3180  initBuchMoraPos(strat);
3181  initBba(strat);
3182  /*set enterS, spSpolyShort, reduce, red, initEcart, initEcartPair*/
3183  strat->posInL=posInL0; /* ord according pComp */
3184 
3185  /*Shdl=*/initBuchMora(F, Q, strat);
3186  reduc = olddeg = 0;
3187 
3188 #ifndef NO_BUCKETS
3189  if (!TEST_OPT_NOT_BUCKETS)
3190  strat->use_buckets = 1;
3191 #endif
3192 
3193  // redtailBBa against T for inhomogenous input
3194  if (!TEST_OPT_OLDSTD)
3195  withT = ! strat->homog;
3196 
3197  // strat->posInT = posInT_pLength;
3198  kTest_TS(strat);
3199 
3200 #ifdef HAVE_TAIL_RING
3201  kStratInitChangeTailRing(strat);
3202 #endif
3203 
3204  /* compute------------------------------------------------------- */
3205  while (strat->Ll >= 0)
3206  {
3207  #ifdef KDEBUG
3208  if (TEST_OPT_DEBUG) messageSets(strat);
3209  #endif
3210  if (strat->Ll== 0) strat->interpt=TRUE;
3211  /* picks the last element from the lazyset L */
3212  strat->P = strat->L[strat->Ll];
3213  strat->Ll--;
3214 
3215  if (strat->P.p1 == NULL)
3216  {
3217  // for input polys, prepare reduction
3218  strat->P.PrepareRed(strat->use_buckets);
3219  }
3220 
3221  if (strat->P.p == NULL && strat->P.t_p == NULL)
3222  {
3223  red_result = 0;
3224  }
3225  else
3226  {
3227  if (TEST_OPT_PROT)
3228  message(strat->P.pFDeg(),
3229  &olddeg,&reduc,strat, red_result);
3230 
3231  /* reduction of the element chosen from L */
3232  red_result = strat->red(&strat->P,strat);
3233  }
3234 
3235  // reduction to non-zero new poly
3236  if (red_result == 1)
3237  {
3238  /* statistic */
3239  if (TEST_OPT_PROT) PrintS("s");
3240 
3241  // get the polynomial (canonicalize bucket, make sure P.p is set)
3242  strat->P.GetP(strat->lmBin);
3243 
3244  int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
3245 
3246  // reduce the tail and normalize poly
3247  // in the ring case we cannot expect LC(f) = 1,
3248  // therefore we call pCleardenom instead of pNorm
3250  {
3251  strat->P.pCleardenom();
3252  if (0)
3253  //if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3254  {
3255  strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
3256  strat->P.pCleardenom();
3257  }
3258  }
3259  else
3260  {
3261  strat->P.pNorm();
3262  if (0)
3263  //if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
3264  strat->P.p = redtailBba(&(strat->P),pos-1,strat, withT);
3265  }
3266 
3267 #ifdef KDEBUG
3268  if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
3269 #endif
3270 
3271  // enter into S, L, and T
3272  if ((!TEST_OPT_IDLIFT) || (pGetComp(strat->P.p) <= strat->syzComp))
3273  {
3274  enterT(strat->P, strat);
3275  // posInS only depends on the leading term
3276  strat->enterS(strat->P, pos, strat, strat->tl);
3277 
3278  if (pos<strat->sl)
3279  {
3280  need_retry++;
3281  // move all "larger" elements fromS to L
3282  // remove them from T
3283  int ii=pos+1;
3284  for(;ii<=strat->sl;ii++)
3285  {
3286  LObject h;
3287  memset(&h,0,sizeof(h));
3288  h.tailRing=strat->tailRing;
3289  h.p=strat->S[ii]; strat->S[ii]=NULL;
3290  strat->initEcart(&h);
3291  h.sev=strat->sevS[ii];
3292  int jj=strat->tl;
3293  while (jj>=0)
3294  {
3295  if (strat->T[jj].p==h.p)
3296  {
3297  strat->T[jj].p=NULL;
3298  if (jj<strat->tl)
3299  {
3300  memmove(&(strat->T[jj]),&(strat->T[jj+1]),
3301  (strat->tl-jj)*sizeof(strat->T[jj]));
3302  memmove(&(strat->sevT[jj]),&(strat->sevT[jj+1]),
3303  (strat->tl-jj)*sizeof(strat->sevT[jj]));
3304  }
3305  strat->tl--;
3306  break;
3307  }
3308  jj--;
3309  }
3310  int lpos=strat->posInL(strat->L,strat->Ll,&h,strat);
3311  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,lpos);
3312  #ifdef KDEBUG
3313  if (TEST_OPT_DEBUG)
3314  {
3315  Print("move S[%d] -> L[%d]: ",ii,pos);
3316  p_wrp(h.p,currRing, strat->tailRing);
3317  PrintLn();
3318  }
3319  #endif
3320  }
3321  if (strat->fromQ!=NULL)
3322  {
3323  for(ii=pos+1;ii<=strat->sl;ii++) strat->fromQ[ii]=0;
3324  }
3325  strat->sl=pos;
3326  }
3327  }
3328  else
3329  {
3330  // clean P
3331  }
3332  kDeleteLcm(&strat->P);
3333  }
3334 
3335 #ifdef KDEBUG
3336  if (TEST_OPT_DEBUG)
3337  {
3338  messageSets(strat);
3339  }
3340  memset(&(strat->P), 0, sizeof(strat->P));
3341 #endif
3342  //kTest_TS(strat);: i_r out of sync in kInterRedBba, but not used!
3343  }
3344 #ifdef KDEBUG
3345  //if (TEST_OPT_DEBUG) messageSets(strat);
3346 #endif
3347  /* complete reduction of the standard basis--------- */
3348 
3349  if((need_retry<=0) && (TEST_OPT_REDSB))
3350  {
3351  completeReduce(strat);
3352  if (strat->completeReduce_retry)
3353  {
3354  // completeReduce needed larger exponents, retry
3355  // hopefully: kStratChangeTailRing already provided a larger tailRing
3356  // (otherwise: it will fail again)
3357  strat->completeReduce_retry=FALSE;
3358  completeReduce(strat);
3359  if (strat->completeReduce_retry)
3360  {
3361 #ifdef HAVE_TAIL_RING
3362  if(currRing->bitmask>strat->tailRing->bitmask)
3363  {
3364  // retry without T
3365  strat->completeReduce_retry=FALSE;
3366  cleanT(strat);strat->tailRing=currRing;
3367  int i;
3368  for(i=strat->sl;i>=0;i--) strat->S_2_R[i]=-1;
3369  completeReduce(strat);
3370  }
3371  if (strat->completeReduce_retry)
3372 #endif
3373  Werror("exponent bound is %ld",currRing->bitmask);
3374  }
3375  }
3376  }
3377  else if (TEST_OPT_PROT) PrintLn();
3378 
3379 
3380  /* release temp data-------------------------------- */
3381  exitBuchMora(strat);
3382 // if (TEST_OPT_WEIGHTM)
3383 // {
3384 // pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
3385 // if (ecartWeights)
3386 // {
3387 // omFreeSize((ADDRESS)ecartWeights,((currRing->N)+1)*sizeof(short));
3388 // ecartWeights=NULL;
3389 // }
3390 // }
3391  //if (TEST_OPT_PROT) messageStat(0/*hilbcount*/,strat);
3392  if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
3393  ideal res=strat->Shdl;
3394  strat->Shdl=NULL;
3395  delete strat;
3396  return res;
3397 }
3398 ideal kInterRed (ideal F, ideal Q)
3399 {
3400 #ifdef HAVE_PLURAL
3401  if(rIsPluralRing(currRing)) return kInterRedOld(F,Q);
3402 #endif
3405  )
3406  return kInterRedOld(F,Q);
3407 
3408  //return kInterRedOld(F,Q);
3409 
3410  BITSET save1;
3411  SI_SAVE_OPT1(save1);
3412  //si_opt_1|=Sy_bit(OPT_NOT_SUGAR);
3414  //si_opt_1&= ~Sy_bit(OPT_REDTAIL);
3415  //si_opt_1&= ~Sy_bit(OPT_REDSB);
3416  //extern char * showOption() ;
3417  //Print("%s\n",showOption());
3418 
3419  int need_retry;
3420  int counter=3;
3421  ideal res, res1;
3422  int elems;
3423  ideal null=NULL;
3424  if ((Q==NULL) || (!TEST_OPT_REDSB))
3425  {
3426  elems=idElem(F);
3427  res=kInterRedBba(F,Q,need_retry);
3428  }
3429  else
3430  {
3431  ideal FF=idSimpleAdd(F,Q);
3432  res=kInterRedBba(FF,NULL,need_retry);
3433  idDelete(&FF);
3434  null=idInit(1,1);
3435  if (need_retry)
3436  res1=kNF(null,Q,res,0,KSTD_NF_LAZY);
3437  else
3438  res1=kNF(null,Q,res);
3439  idDelete(&res);
3440  res=res1;
3441  need_retry=1;
3442  }
3443  if (idElem(res)<=1) need_retry=0;
3444  while (need_retry && (counter>0))
3445  {
3446  #ifdef KDEBUG
3447  if (TEST_OPT_DEBUG) { Print("retry counter %d\n",counter); }
3448  #endif
3449  res1=kInterRedBba(res,Q,need_retry);
3450  int new_elems=idElem(res1);
3451  counter -= (new_elems >= elems);
3452  elems = new_elems;
3453  idDelete(&res);
3454  if (idElem(res1)<=1) need_retry=0;
3455  if ((Q!=NULL) && (TEST_OPT_REDSB))
3456  {
3457  if (need_retry)
3458  res=kNF(null,Q,res1,0,KSTD_NF_LAZY);
3459  else
3460  res=kNF(null,Q,res1);
3461  idDelete(&res1);
3462  }
3463  else
3464  res = res1;
3465  if (idElem(res)<=1) need_retry=0;
3466  }
3467  if (null!=NULL) idDelete(&null);
3468  SI_RESTORE_OPT1(save1);
3469  idSkipZeroes(res);
3470  return res;
3471 }
3472 
3473 // returns TRUE if mora should use buckets, false otherwise
3475 {
3476 #ifdef MORA_USE_BUCKETS
3478  return FALSE;
3479  if (strat->red == redFirst)
3480  {
3481 #ifdef NO_LDEG
3482  if (strat->syzComp==0)
3483  return TRUE;
3484 #else
3485  if ((strat->homog || strat->honey) && (strat->syzComp==0))
3486  return TRUE;
3487 #endif
3488  }
3489  else
3490  {
3491  #ifdef HAVE_RINGS
3492  assume(strat->red == redEcart || strat->red == redRiloc);
3493  #else
3494  assume(strat->red == redEcart);
3495  #endif
3496  if (strat->honey && (strat->syzComp==0))
3497  return TRUE;
3498  }
3499 #endif
3500  return FALSE;
3501 }
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:755
#define OPT_REDSB
Definition: options.h:75
#define __p_GetComp(p, r)
Definition: monomials.h:63
#define pSetmComp(p)
TODO:
Definition: polys.h:268
void initEcartPairBba(LObject *Lp, poly, poly, int, int)
Definition: kutil.cc:1299
void updateT(kStrategy strat)
Definition: kstd1.cc:1177
poly k_NF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce, const ring _currRing)
NOTE: this is just a wrapper which sets currRing for the actual kNF call.
Definition: kstd1.cc:3033
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.h:280
ideal SCAQuotient(const ring r)
Definition: sca.h:10
KINLINE TObject ** initR()
Definition: kInline.h:95
unsigned si_opt_1
Definition: options.c:5
char fromT
Definition: kutil.h:377
int j
Definition: facHensel.cc:105
void enterSSba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:9380
char kHEdgeFound
Definition: kutil.h:374
#define OPT_PROT
Definition: options.h:74
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3596
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:2822
#define pSetm(p)
Definition: polys.h:266
int redRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:715
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
Definition: coeffs.h:515
int HCord
Definition: kutil.cc:236
void PrintLn()
Definition: reporter.cc:310
int redRing_Z(LObject *h, kStrategy strat)
Definition: kstd2.cc:568
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5296
#define Print
Definition: emacs.cc:80
int syzComp
Definition: kutil.h:352
static poly redMoraNFRing(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:762
int redEcart(LObject *h, kStrategy strat)
Definition: kstd1.cc:166
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
#define TEST_OPT_DEGBOUND
Definition: options.h:112
#define pAdd(p, q)
Definition: polys.h:198
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:10025
BOOLEAN(* rewCrit1)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:289
#define OPT_INFREDTAIL
Definition: options.h:93
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:7954
poly kHEdge
Definition: kutil.h:325
pLDegProc pOrigLDeg_TailRing
Definition: kutil.h:295
void initMora(ideal F, kStrategy strat)
Definition: kstd1.cc:1460
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
class sLObject LObject
Definition: kutil.h:54
KINLINE TSet initT()
Definition: kInline.h:84
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:7995
bool sigdrop
Definition: kutil.h:358
#define TEST_OPT_PROT
Definition: options.h:102
#define pMaxComp(p)
Definition: polys.h:294
int Ll
Definition: kutil.h:349
#define pSetExp(p, i, v)
Definition: polys.h:42
void kEcartWeights(poly *s, int sl, short *eweight, const ring R)
Definition: weight.cc:182
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly, kStrategy strat, int start=0)
Definition: kutil.cc:7129
#define FALSE
Definition: auxiliary.h:94
Compatiblity layer for legacy polynomial operations (over currRing)
int * S_2_R
Definition: kutil.h:340
ideal kSba(ideal F, ideal Q, tHomog h, intvec **w, int sbaOrder, int arri, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
Definition: kstd1.cc:2273
char noTailReduction
Definition: kutil.h:376
long totaldegreeWecart(poly p, ring r)
Definition: weight.cc:217
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:3192
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:10198
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
short * ecartWeights
Definition: weight0.c:28
int sbaEnterS
Definition: kutil.h:361
#define pTest(p)
Definition: polys.h:410
int redFirst(LObject *h, kStrategy strat)
Definition: kstd1.cc:528
static poly last
Definition: hdegree.cc:1076
BOOLEAN * NotUsedAxis
Definition: kutil.h:330
long p_WDegree(poly p, const ring r)
Definition: p_polys.cc:704
char interpt
Definition: kutil.h:369
static int doRed(LObject *h, TObject *with, BOOLEAN intoT, kStrategy strat, bool redMoraNF)
Definition: kstd1.cc:116
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define idSimpleAdd(A, B)
Definition: ideals.h:42
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:290
void initSba(ideal F, kStrategy strat)
Definition: kstd1.cc:1390
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:586
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
ideal kStdShift(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
Definition: kstd1.cc:2569
long pLDeg0c(poly p, int *l, const ring r)
Definition: p_polys.cc:760
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4859
poly kNoether
Definition: kutil.h:326
#define OPT_OLDSTD
Definition: options.h:85
int tl
Definition: kutil.h:348
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
#define TEST_OPT_MULTBOUND
Definition: options.h:113
char noClearS
Definition: kutil.h:400
#define TRUE
Definition: auxiliary.h:98
#define TEST_OPT_REDSB
Definition: options.h:103
static void kDeleteLcm(LObject *P)
Definition: kutil.h:876
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition: kstd1.cc:2088
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
Definition: kspoly.cc:185
#define kTest(A)
Definition: kutil.h:653
char LDegLast
Definition: kutil.h:383
unsigned long * sevT
Definition: kutil.h:321
void * ADDRESS
Definition: auxiliary.h:133
BOOLEAN(* rewCrit3)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.h:291
void(* initEcartPair)(LObject *h, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.h:283
#define SI_SAVE_OPT1(A)
Definition: options.h:22
int ak
Definition: kutil.h:351
poly preIntegerCheck(const ideal Forig, const ideal Q)
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known const...
Definition: kutil.cc:10968
void cancelunit(LObject *L, BOOLEAN inNF)
Definition: kutil.cc:333
void WerrorS(const char *s)
Definition: feFopen.cc:24
int k
Definition: cfEzgcd.cc:92
void initBba(kStrategy strat)
Definition: kstd1.cc:1334
#define TEST_OPT_DEBUG
Definition: options.h:107
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1260
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:504
#define Q
Definition: sirandom.c:25
#define nEqual(n1, n2)
Definition: numbers.h:20
int redSig(LObject *h, kStrategy strat)
Definition: kstd2.cc:982
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2178
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:44
#define loop
Definition: structs.h:80
#define WarnS
Definition: emacs.cc:78
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:2536
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:408
#define BITSET
Definition: structs.h:20
int(* red)(LObject *L, kStrategy strat)
Definition: kutil.h:274
#define omAlloc(size)
Definition: omAllocDecl.h:210
void initBuchMoraPosRing(kStrategy strat)
Definition: kutil.cc:10111
int redHomog(LObject *h, kStrategy strat)
Definition: kstd2.cc:822
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition: kInline.h:1158
poly p_KillSquares(const poly p, const short iFirstAltVar, const short iLastAltVar, const ring r)
Definition: sca.cc:1465
#define Sy_bit(x)
Definition: options.h:32
int(* posInT)(const TSet T, const int tl, LObject &h)
Definition: kutil.h:277
void HEckeTest(poly pp, kStrategy strat)
Definition: kutil.cc:468
char posInLOldFlag
Definition: kutil.h:380
int currIdx
Definition: kutil.h:313
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:838
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:37
#define pGetComp(p)
Component.
Definition: polys.h:37
char length_pLength
Definition: kutil.h:385
void updateL(kStrategy strat)
Definition: kstd1.cc:1039
int minim
Definition: kutil.h:356
char use_buckets
Definition: kutil.h:381
int lastAxis
Definition: kutil.h:354
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR=-1)
Definition: kutil.cc:1929
BITSET validOpts
Definition: kstd1.cc:57
char completeReduce_retry
Definition: kutil.h:401
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:11476
int Kstd1_mu
Definition: kutil.cc:238
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:104
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:543
pShallowCopyDeleteProc pGetShallowCopyDeleteProc(ring, ring)
#define TEST_OPT_FINDET
Definition: options.h:110
void enterT(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9576
int HCord
Definition: kutil.h:353
#define mflush()
Definition: reporter.h:57
void missingAxis(int *last, kStrategy strat)
Definition: kstd1.cc:925
int redHoney(LObject *h, kStrategy strat)
Definition: kstd2.cc:1664
#define pIter(p)
Definition: monomials.h:37
pFDegProc pOrigFDeg
Definition: kutil.h:292
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1203
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
intvec * kHomW
Definition: kstd1.cc:2063
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:342
#define M
Definition: sirandom.c:24
void(* initEcart)(TObject *L)
Definition: kutil.h:276
int redLazy(LObject *h, kStrategy strat)
Definition: kstd2.cc:1519
int blockredmax
Definition: kutil.h:364
void(* enterOnePair)(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.h:286
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8075
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:3503
CanonicalForm b
Definition: cfModGcd.cc:4044
ideal kInterRedBba(ideal F, ideal Q, int &need_retry)
Definition: kstd1.cc:3138
if(yy_init)
Definition: libparse.cc:1418
omError_t omTestMemory(int check_level)
Definition: omDebug.c:94
pLDegProc pOrigLDeg
Definition: kutil.h:293
#define KSTD_NF_LAZY
Definition: kstd1.h:17
intvec * kModW
Definition: kstd1.cc:2063
void initEcartPairMora(LObject *Lp, poly, poly, int ecartF, int ecartG)
Definition: kutil.cc:1306
#define TEST_OPT_INTSTRATEGY
Definition: options.h:109
Definition: intvec.h:19
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
#define setmaxT
Definition: kutil.h:33
#define kTest_TS(A)
Definition: kutil.h:654
CanonicalForm res
Definition: facAbsFact.cc:64
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:468
#define OPT_REDTAIL
Definition: options.h:90
#define TEST_V_DEG_STOP
Definition: options.h:135
tHomog
Definition: structs.h:39
#define TEST_OPT_STAIRCASEBOUND
Definition: options.h:114
poly redtail(LObject *L, int end_pos, kStrategy strat)
Definition: kutil.cc:7405
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3597
#define omFree(addr)
Definition: omAllocDecl.h:261
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
Definition: kutil.cc:9856
void enterSMora(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1270
#define TEST_OPT_OLDSTD
Definition: options.h:121
int scMult0Int(ideal S, ideal Q, const ring tailRing)
Definition: hdegree.cc:918
#define assume(x)
Definition: mod2.h:390
char no_prod_crit
Definition: kutil.h:392
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:397
intset fromQ
Definition: kutil.h:317
#define messageSets(s)
Definition: kutil.h:540
poly kNF1(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd1.cc:1766
LObject * LSet
Definition: kutil.h:56
void initEcartBBA(TObject *h)
Definition: kutil.cc:1292
void updateLHC(kStrategy strat)
Definition: kstd1.cc:1110
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:248
#define kTest_L(T, R)
Definition: kutil.h:657
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl.cc )
Definition: polys.h:152
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether &#39;a&#39; is divisible &#39;b&#39;; for r encoding a field: TRUE iff &#39;b&#39; does not represent zero in Z:...
Definition: coeffs.h:775
long pLDeg0(poly p, int *l, const ring r)
Definition: p_polys.cc:729
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
Definition: polys.h:146
#define pp_Test(p, lmRing, tailRing)
Definition: p_polys.h:164
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
Definition: kutil.h:282
#define omfree(addr)
Definition: omAllocDecl.h:237
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2075
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
Definition: p_polys.h:1853
ideal kInterRed(ideal F, ideal Q)
Definition: kstd1.cc:3398
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition: kspoly.cc:1145
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
Definition: kstd2.cc:326
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:4163
#define KSTD_NF_ECART
Definition: kstd1.h:19
#define OPT_NOT_SUGAR
Definition: options.h:77
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted ...
#define pSetComp(p, v)
Definition: polys.h:38
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
Definition: kutil.cc:11377
int posInL0(const LSet set, const int length, LObject *p, const kStrategy)
Definition: kutil.cc:6065
LObject P
Definition: kutil.h:298
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:233
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:9874
ideal M
Definition: kutil.h:301
unsigned sbaOrder
Definition: kutil.h:312
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
void reorderL(kStrategy strat)
Definition: kstd1.cc:867
BOOLEAN siCntrlc
Definition: options.c:14
int i
Definition: cfEzgcd.cc:125
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3046
void PrintS(const char *s)
Definition: reporter.cc:284
poly tail
Definition: kutil.h:332
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
Definition: kutil.cc:244
int redSigRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:1149
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:312
static void kOptimizeLDeg(pLDegProc ldeg, kStrategy strat)
Definition: kstd1.cc:97
#define pOne()
Definition: polys.h:310
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5731
int(* posInLOld)(const LSet Ls, const int Ll, LObject *Lo, const kStrategy strat)
Definition: kutil.h:284
CanonicalForm H
Definition: facAbsFact.cc:64
TObject ** R
Definition: kutil.h:338
static unsigned pLength(poly a)
Definition: p_polys.h:191
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
Definition: polys.h:67
polyset S
Definition: kutil.h:302
#define IDELEMS(i)
Definition: simpleideals.h:23
poly kNFBound(ideal F, ideal Q, poly p, int bound, int syzComp, int lazyReduce)
Definition: kstd1.cc:2877
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static short scaFirstAltVar(ring r)
Definition: sca.h:18
int tmax
Definition: kutil.h:348
BOOLEAN rHasMixedOrdering(const ring r)
Definition: ring.h:756
void enterT_strong(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:9676
ideal idCopy(ideal A)
Definition: ideals.h:60
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3609
void rChangeCurrRing(ring r)
Definition: polys.cc:14
#define OPT_SUGARCRIT
Definition: options.h:79
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:10905
BOOLEAN arriRewCriterion(poly, unsigned long, poly, kStrategy strat, int start=0)
Definition: kutil.cc:7188
#define OPT_INTSTRATEGY
Definition: options.h:91
#define BVERBOSE(a)
Definition: options.h:35
#define TEST_OPT_RETURN_SB
Definition: options.h:111
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:856
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
Definition: khstd.cc:28
intset ecartS
Definition: kutil.h:305
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int)
Definition: kutil.cc:7213
s_poly_proc_t s_poly
Definition: kutil.h:296
int p_IsPurePower(const poly p, const ring r)
return i, if head depends only on var(i)
Definition: p_polys.cc:1216
#define TEST_OPT_WEIGHTM
Definition: options.h:119
char homog
Definition: kutil.h:370
void(* chainCrit)(poly p, int ecart, kStrategy strat)
Definition: kutil.h:287
LSet L
Definition: kutil.h:323
char z2homog
Definition: kutil.h:372
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
Definition: kutil.cc:11135
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:479
#define NULL
Definition: omList.c:12
#define TEST_OPT_IDLIFT
Definition: options.h:127
intvec * kHomW
Definition: kutil.h:334
void cleanT(kStrategy strat)
Definition: kutil.cc:538
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1520
#define OPT_WEIGHTM
Definition: options.h:96
LSet B
Definition: kutil.h:324
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
Definition: kutil.cc:4831
int Lmax
Definition: kutil.h:349
void firstUpdate(kStrategy strat)
Definition: kstd1.cc:1203
BOOLEAN rHasGlobalOrdering(const ring r)
Definition: ring.h:754
ring tailRing
Definition: kutil.h:341
void khCheckLocInhom(ideal Q, intvec *w, intvec *hilb, int &count, kStrategy strat)
Definition: khstd.cc:133
ideal kMin_std(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
Definition: kstd1.cc:2673
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:358
#define TEST_OPT_SB_1
Definition: options.h:117
BOOLEAN hasPurePower(const poly p, int last, int *length, kStrategy strat)
Definition: kstd1.cc:958
int blockred
Definition: kutil.h:363
void reorderT(kStrategy strat)
Definition: kstd1.cc:887
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:263
BOOLEAN(* s_poly_proc_t)(kStrategy strat)
Definition: kstd1.h:14
const CanonicalForm & w
Definition: facAbsFact.cc:55
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:5035
#define pWTotaldegree(p)
Definition: polys.h:278
#define pDelete(p_ptr)
Definition: polys.h:181
char overflow
Definition: kutil.h:402
static short scaLastAltVar(ring r)
Definition: sca.h:25
intvec * kModW
Definition: kutil.h:333
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:9034
unsigned long * sevS
Definition: kutil.h:318
ideal freegb(ideal I)
Definition: kstd2.cc:4459
static bool rIsSCA(const ring r)
Definition: nc.h:190
void completeReduce(kStrategy strat, BOOLEAN withT)
Definition: kutil.cc:10719
#define pNext(p)
Definition: monomials.h:36
static poly redMoraNF(poly h, kStrategy strat, int flag)
Definition: kstd1.cc:662
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long kModDeg(poly p, ring r)
Definition: kstd1.cc:2065
char honey
Definition: kutil.h:375
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:3405
#define setmaxTinc
Definition: kutil.h:34
#define OPT_REDTHROUGH
Definition: options.h:81
long maxdegreeWecart(poly p, int *l, ring r)
Definition: weight.cc:247
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:10507
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced ...
Definition: polys.h:70
char update
Definition: kutil.h:379
int sl
Definition: kutil.h:346
int idElem(const ideal F)
count non-zero elements
TSet T
Definition: kutil.h:322
char posInLDependsOnLength
Definition: kutil.h:387
static void p_LmDelete(poly p, const ring r)
Definition: p_polys.h:710
omBin lmBin
Definition: kutil.h:342
static BOOLEAN kMoraUseBucket(kStrategy strat)
Definition: kstd1.cc:3474
void p_wrp(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:280
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start)
return -1 if no divisor is found number of first divisor in T, otherwise
Definition: kstd2.cc:216
BOOLEAN newHEdge(kStrategy strat)
Definition: kutil.cc:10841
void enterSMoraNF(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kstd1.cc:1324
void initEcartNormal(TObject *h)
Definition: kutil.cc:1284
#define OPT_DEGBOUND
Definition: options.h:89
int p
Definition: cfModGcd.cc:4019
void wrp(poly p)
Definition: polys.h:305
#define kTest_T(T)
Definition: kutil.h:655
#define TEST_OPT_FASTHC
Definition: options.h:108
int LazyPass
Definition: kutil.h:351
int Kstd1_deg
Definition: kutil.cc:237
BITSET kOptions
Definition: kstd1.cc:42
#define OPT_NOTREGULARITY
Definition: options.h:95
int newIdeal
Definition: kutil.h:355
#define TEST_OPT_REDTHROUGH
Definition: options.h:120
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition: kutil.cc:11292
static ideal nc_GB(const ideal F, const ideal Q, const intvec *w, const intvec *hilb, kStrategy strat, const ring r)
Definition: nc.h:27
ideal Shdl
Definition: kutil.h:299
#define OPT_INTERRUPT
Definition: options.h:78
int(* red2)(LObject *L, kStrategy strat)
Definition: kutil.h:275
static Poly * h
Definition: janet.cc:971
int BOOLEAN
Definition: auxiliary.h:85
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
KINLINE poly kNoetherTail()
Definition: kInline.h:66
#define SI_RESTORE_OPT1(A)
Definition: options.h:25
KINLINE BOOLEAN arriRewDummy(poly, unsigned long, poly, kStrategy, int)
Definition: kInline.h:1203
static BOOLEAN rField_is_numeric(const ring r)
Definition: ring.h:510
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:10274
void Werror(const char *fmt,...)
Definition: reporter.cc:189
pFDegProc pOrigFDeg_TailRing
Definition: kutil.h:294
#define OPT_FASTHC
Definition: options.h:84
int posInL10(const LSet set, const int length, LObject *p, const kStrategy strat)
Definition: kstd1.cc:1006
int LazyDegree
Definition: kutil.h:351
void kDebugPrint(kStrategy strat)
Definition: kutil.cc:11923
class sTObject TObject
Definition: kutil.h:53
ideal mora(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd1.cc:1517
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
Definition: kutil.cc:9261
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180
#define idTest(id)
Definition: ideals.h:47
#define pNormalize(p)
Definition: polys.h:312