kutil.h
Go to the documentation of this file.
1 #ifndef KUTIL_H
2 #define KUTIL_H
3 /****************************************
4 * Computer Algebra System SINGULAR *
5 ****************************************/
6 /*
7 * ABSTRACT: kernel: utils for kStd
8 */
9 
10 
11 #include <string.h>
12 
13 #include <omalloc/omalloc.h>
14 #include <omalloc/omallocClass.h>
15 #include <misc/mylimits.h>
16 
17 
18 #include <kernel/polys.h>
20 
21 #include <kernel/structs.h>
22 #include <kernel/GBEngine/kstd1.h> /* for s_poly_proc_t */
23 
24 // define if tailrings should be used
25 #define HAVE_TAIL_RING
26 
27 #if 1
28 #define setmax 16
29 #define setmaxL ((4096-12)/sizeof(LObject))
30 #define setmaxLinc ((4096)/sizeof(LObject))
31 
32 #define setmaxT 64
33 #define setmaxTinc 32
34 #else
35 #define setmax 16
36 #define setmaxL 16
37 #define setmaxLinc 16
38 #define setmaxT 16
39 #define setmaxTinc 16
40 #endif
41 
42 // if you want std computations as in Singular version < 2:
43 // This disables RedThrough, tailReductions against T (bba),
44 // sets posInT = posInT15 (bba, strat->honey), and enables redFirst with LDeg
45 // NOTE: can be achieved with option(oldStd)
46 
47 #undef NO_KINLINE
48 #if !defined(KDEBUG) && !defined(NO_INLINE)
49 #define KINLINE inline
50 #else
51 #define KINLINE
52 #define NO_KINLINE 1
53 #endif
54 
55 typedef int* intset;
56 typedef int64 wlen_type;
58 
59 typedef class sTObject TObject;
60 typedef class sLObject LObject;
61 typedef TObject * TSet;
62 typedef LObject * LSet;
63 
66 
69 
70 class sTObject
71 {
72 public:
73  unsigned long sevSig;
74  poly sig; // the signature of the element
75  poly p; // Lm(p) \in currRing Tail(p) \in tailRing
76  poly t_p; // t_p \in tailRing: as monomials Lm(t_p) == Lm(p)
77  poly max; // p_GetMaxExpP(pNext(p))
78  ring tailRing;
79  long FDeg; // pFDeg(p)
80  int ecart,
81  length, // as of pLDeg
82  pLength, // either == 0, or == pLength(p)
83  i_r; // index of TObject in R set, or -1 if not in T
84  BOOLEAN is_normalized; // true, if pNorm was called on p, false otherwise
85  // used in incremental sba() with F5C:
86  // we know some of the redundant elements in
87  // strat->T beforehand, so we can just discard
88  // them and do not need to consider them in the
89  // interreduction process
91  // used in sba's sig-safe reduction:
92  // sometimes we already know that a reducer
93  // is sig-safe, so no need for a real
94  // sig-safeness check
96 
97 
98 #ifdef HAVE_PLURAL
99  BOOLEAN is_special; // true, it is a new special S-poly (e.g. for SCA)
100 #endif
101 
102  // initialization
103  KINLINE void Init(ring r = currRing);
104  KINLINE sTObject(ring tailRing = currRing);
105  KINLINE sTObject(poly p, ring tailRing = currRing);
106  KINLINE sTObject(poly p, ring c_r, ring tailRing);
107  KINLINE sTObject(sTObject* T, int copy);
108 
109  KINLINE void Set(ring r=currRing);
110  KINLINE void Set(poly p_in, ring r=currRing);
111  KINLINE void Set(poly p_in, ring c_r, ring t_r);
112 
113  // Frees the polys of T
114  KINLINE void Delete();
115  // Sets polys to NULL
116  KINLINE void Clear();
117  // makes a copy of the poly of T
118  KINLINE void Copy();
119 
120  // ring-dependent Lm access: these might result in allocation of monomials
121  KINLINE poly GetLmCurrRing();
122  KINLINE poly GetLmTailRing();
123  KINLINE poly GetLm(ring r);
124  // this returns Lm and ring r (preferably from tailRing), but does not
125  // allocate a new poly
126  KINLINE void GetLm(poly &p, ring &r) const;
127 
128 #ifdef OLIVER_PRIVAT_LT
129  // routines for calc. with rings
130  KINLINE poly GetLtCurrRing();
131  KINLINE poly GetLtTailRing();
132  KINLINE poly GetLt(ring r);
133  KINLINE void GetLt(poly &p, ring &r) const;
134 #endif
135 
136  KINLINE BOOLEAN IsNull() const;
137 
138  KINLINE int GetpLength();
139 
140  // makes sure that T.p exists
141  KINLINE void SetLmCurrRing();
142 
143  // Iterations
144  // simply get the next monomial
145  KINLINE poly Next();
146  KINLINE void LmDeleteAndIter();
147 
148  // deg stuff
149  // compute pTotalDegree
150  KINLINE long pTotalDeg() const;
151  // computes pFDeg
152  KINLINE long pFDeg() const;
153  // computes and sets FDeg
154  KINLINE long SetpFDeg();
155  // gets stored FDeg
156  KINLINE long GetpFDeg() const;
157 
158  // computes pLDeg
159  KINLINE long pLDeg();
160  // sets length, FDeg, returns LDeg
161  KINLINE long SetDegStuffReturnLDeg();
162 
163  // arithmetic
164  KINLINE void Mult_nn(number n);
165  KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin,
166  pShallowCopyDeleteProc p_shallow_copy_delete,
167  BOOLEAN set_max = TRUE);
168  // manipulations
169  KINLINE void pNorm();
170  KINLINE void pCleardenom();
171 
172 #ifdef KDEBUG
173  void wrp();
174 #endif
175 };
176 
177 extern int strat_nr;
178 
179 class sLObject : public sTObject
180 {
181 
182 public:
183  unsigned long sev;
184  poly p1,p2; /*- the pair p comes from,
185  lm(pi) in currRing, tail(pi) in tailring -*/
186 
187  poly lcm; /*- the lcm of p1,p2 -*/
189  int i_r1, i_r2;
190  unsigned checked; // this is the index of S up to which
191  // the corresponding LObject was already checked in
192  // critical pair creation => when entering the
193  // reduction process it is enough to start a second
194  // rewritten criterion check from checked+1 onwards
196  // NOTE: If prod_crit = TRUE then the corresponding pair is
197  // detected by Buchberger's Product Criterion and can be
198  // deleted
199 
200  // initialization
201  KINLINE void Init(ring tailRing = currRing);
204  KINLINE sLObject(poly p, ring c_r, ring tailRing);
205 
206  // Frees the polys of L
207  KINLINE void Delete();
208  KINLINE void Clear();
209 
210  // Iterations
211  KINLINE void LmDeleteAndIter();
212  KINLINE poly LmExtractAndIter();
213 
214  // spoly related things
215  // preparation for reduction if not spoly
216  KINLINE void PrepareRed(BOOLEAN use_bucket);
217  KINLINE void SetLmTail(poly lm, poly new_p, int length,
218  int use_bucket, ring r);
219  KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether);
220  KINLINE void Tail_Mult_nn(number n);
221  // deletes bucket, makes sure that p and t_p exists
222  KINLINE poly GetP(omBin lmBin = NULL);
223  // similar, except that only t_p exists
224  KINLINE poly GetTP();
225 
226  // does not delete bucket, just canonicalizes it
227  // returned poly is such that Lm(p) \in currRing, Tail(p) \in tailRing
228  KINLINE poly CanonicalizeP();
229 
230  // makes a copy of the poly of L
231  KINLINE void Copy();
232  // gets the poly and makes a copy of it
233  KINLINE poly CopyGetP();
234 
235  KINLINE int GetpLength();
236  KINLINE long pLDeg(BOOLEAN use_last);
237  KINLINE long pLDeg();
238  KINLINE int SetLength(BOOLEAN lengt_pLength = FALSE);
239  KINLINE long SetDegStuffReturnLDeg();
240  KINLINE long SetDegStuffReturnLDeg(BOOLEAN use_last);
241 
242  // returns minimal component of p
243  KINLINE long MinComp();
244  // returns component of p
245  KINLINE long Comp();
246 
247  KINLINE void ShallowCopyDelete(ring new_tailRing,
248  pShallowCopyDeleteProc p_shallow_copy_delete);
249 
250  // sets sev
251  KINLINE void SetShortExpVector();
252 
253  // enable assignment from TObject
254  KINLINE sLObject& operator=(const sTObject&);
255 
256  // get T's corresponding to p1, p2: they might return NULL
257  KINLINE TObject* T_1(const skStrategy* strat);
258  KINLINE TObject* T_2(const skStrategy* strat);
259  KINLINE void T_1_2(const skStrategy* strat,
260  TObject* &T_1, TObject* &T_2);
261 
262  // simplify coefficients
263  KINLINE void Normalize();
264  KINLINE void HeadNormalize();
265 };
266 
267 
268 extern int HCord;
269 
270 class skStrategy : public omallocClass
271 {
272 public:
274  int (*red)(LObject * L,kStrategy strat);
275  int (*red2)(LObject * L,kStrategy strat);
276  void (*initEcart)(TObject * L);
277  int (*posInT)(const TSet T,const int tl,LObject &h);
278  int (*posInLSba)(const LSet set, const int length,
279  LObject* L,const kStrategy strat);
280  int (*posInL)(const LSet set, const int length,
281  LObject* L,const kStrategy strat);
282  void (*enterS)(LObject &h, int pos,kStrategy strat, int atR/* =-1*/ );
283  void (*initEcartPair)(LObject * h, poly f, poly g, int ecartF, int ecartG);
284  int (*posInLOld)(const LSet Ls,const int Ll,
285  LObject* Lo,const kStrategy strat);
286  void (*enterOnePair) (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR /*= -1*/);
287  void (*chainCrit) (poly p,int ecart,kStrategy strat);
288  BOOLEAN (*syzCrit) (poly sig, unsigned long not_sevSig, kStrategy strat);
289  BOOLEAN (*rewCrit1) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
290  BOOLEAN (*rewCrit2) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
291  BOOLEAN (*rewCrit3) (poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start /*= 0*/);
297 
299  ideal Shdl;
300  ideal D; /*V(S) is in D(D)*/
301  ideal M; /*set of minimal generators*/
306  intset fromS; // from which S[i] S[j] comes from
307  // this is important for signature-based
308  // algorithms
309  intset syzIdx;// index in the syz array at which the first
310  // syzygy of component i comes up
311  // important for signature-based algorithms
312  unsigned sbaOrder;
313  int currIdx;
316  wlen_set lenSw; /* for tgb.ccc */
318  unsigned long* sevS;
319  unsigned long* sevSyz;
320  unsigned long* sevSig;
321  unsigned long* sevT;
327  poly t_kHEdge; // same polys in tailring
328  KINLINE poly kNoetherTail();
331  BOOLEAN * pairtest;/*used for enterOnePair*/
335  // procedure for ShalloCopy from tailRing to currRing
337  // pointers to Tobjects R[i] is ith Tobject which is generated
339  // S_2_R[i] yields Tobject which corresponds to S[i]
340  int* S_2_R;
341  ring tailRing;
344  int nr;
345  int cp,c3;
346  int sl,mu;
347  int syzl,syzmax,syzidxmax;
348  int tl,tmax;
349  int Ll,Lmax;
350  int Bl,Bmax;
352  int syzComp;
353  int HCord;
354  int lastAxis;
355  int newIdeal;
356  int minim;
357  #ifdef HAVE_SHIFTBBA
358  int lV;
359  int cv; // in shift bases: counting V criterion
360  #endif
363 #ifdef HAVE_PLURAL
364  BOOLEAN z2homog; // Z_2 - homogeneous input allows product criterion in commutative and SCA cases!
365 #endif
374  // if set, pLDeg(p, l) == (pFDeg(pLast(p), pLength)
376  // if set, then L.length == L.pLength
378  // if set, then posInL does not depend on L.length
380  /*FALSE, if posInL == posInL10*/
381 #ifdef HAVE_PLURAL
382  // set this flag to 1 to stop the product criteria
383  // use ALLOW_PROD_CRIT(strat) to test
385 #define ALLOW_PROD_CRIT(A) (!(A)->no_prod_crit)
386 #else
387 #define ALLOW_PROD_CRIT(A) (1)
388 #endif
390  char news;
391  char newt;/*used for messageSets*/
392  char noClearS;
394  char overflow;
395 
396  skStrategy();
397  ~skStrategy();
398 
399  // return TObject corresponding to S[i]: assume that it exists
400  // i.e. no error checking is done
401  KINLINE TObject* S_2_T(int i);
402  // like S_2_T, except that NULL is returned if it can not be found
403  KINLINE TObject* s_2_t(int i);
404 };
405 
406 void deleteHC(poly *p, int *e, int *l, kStrategy strat);
407 void deleteHC(LObject* L, kStrategy strat, BOOLEAN fromNext = FALSE);
408 void deleteInS (int i,kStrategy strat);
409 void deleteInSSba (int i,kStrategy strat);
410 void cleanT (kStrategy strat);
411 static inline LSet initL (int nr=setmaxL)
412 { return (LSet)omAlloc(nr*sizeof(LObject)); }
413 void deleteInL(LSet set, int *length, int j,kStrategy strat);
414 void enterL (LSet *set,int *length, int *LSetmax, LObject p,int at);
415 void enterSBba (LObject &p,int atS,kStrategy strat, int atR = -1);
416 void enterSSba (LObject &p,int atS,kStrategy strat, int atR = -1);
417 void initEcartPairBba (LObject* Lp,poly f,poly g,int ecartF,int ecartG);
418 void initEcartPairMora (LObject* Lp,poly f,poly g,int ecartF,int ecartG);
419 int posInS (const kStrategy strat, const int length, const poly p,
420  const int ecart_p);
421 int posInT0 (const TSet set,const int length,LObject &p);
422 int posInT1 (const TSet set,const int length,LObject &p);
423 int posInT2 (const TSet set,const int length,LObject &p);
424 int posInT11 (const TSet set,const int length,LObject &p);
425 int posInTSig (const TSet set,const int length,LObject &p);
426 int posInT110 (const TSet set,const int length,LObject &p);
427 int posInT13 (const TSet set,const int length,LObject &p);
428 int posInT15 (const TSet set,const int length,LObject &p);
429 int posInT17 (const TSet set,const int length,LObject &p);
430 int posInT19 (const TSet set,const int length,LObject &p);
431 int posInT_EcartpLength(const TSet set,const int length,LObject &p);
432 
433 #ifdef HAVE_MORE_POS_IN_T
434 int posInT_EcartFDegpLength(const TSet set,const int length,LObject &p);
435 int posInT_FDegpLength(const TSet set,const int length,LObject &p);
436 int posInT_pLength(const TSet set,const int length,LObject &p);
437 #endif
438 
439 
440 void reorderS (int* suc,kStrategy strat);
441 int posInLF5C (const LSet set, const int length,
442  LObject* L,const kStrategy strat);
443 int posInLSig (const LSet set, const int length,
444  LObject* L,const kStrategy strat);
445 int posInLRing (const LSet set, const int length,
446  LObject* L,const kStrategy strat);
447 int posInSyz (const kStrategy strat, const poly sig);
448 int posInL0 (const LSet set, const int length,
449  LObject* L,const kStrategy strat);
450 int posInL11 (const LSet set, const int length,
451  LObject* L,const kStrategy strat);
452 int posInL11Ring (const LSet set, const int length,
453  LObject* L,const kStrategy strat);
454 int posInL11Ringls (const LSet set, const int length,
455  LObject* L,const kStrategy strat);
456 int posInL13 (const LSet set, const int length,
457  LObject* L,const kStrategy strat);
458 int posInL15 (const LSet set, const int length,
459  LObject* L,const kStrategy strat);
460 int posInL17 (const LSet set, const int length,
461  LObject* L,const kStrategy strat);
462 int posInL10 (const LSet set, const int length,
463  LObject* L,const kStrategy strat);
464 int posInL110 (const LSet set, const int length,
465  LObject* L,const kStrategy strat);
467 #ifdef HAVE_RINGS
468 KINLINE poly redtailBba_Z (poly p,int pos,kStrategy strat);
469 poly redtailBba_Z (LObject* L, int pos, kStrategy strat );
470 #endif
471 poly redtailBba (LObject *L, int pos,kStrategy strat,
473 poly redtailSba (LObject *L, int pos,kStrategy strat,
475 poly redtailBba (TObject *T, int pos,kStrategy strat);
476 poly redtail (poly p,int pos,kStrategy strat);
477 poly redtail (LObject *L,int pos,kStrategy strat);
478 poly redNF (poly h,int & max_ind,int nonorm,kStrategy strat);
479 int redNF0 (LObject *P,kStrategy strat);
480 poly redNFTail (poly h,const int sl,kStrategy strat);
481 int redHoney (LObject* h, kStrategy strat);
482 #ifdef HAVE_RINGS
483 int redRing (LObject* h,kStrategy strat);
484 int redRiloc (LObject* h,kStrategy strat);
485 void enterExtendedSpoly(poly h,kStrategy strat);
486 void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR = -1);
487 poly kCreateZeroPoly(long exp[], long cabsind, poly* t_p, ring leadRing, ring tailRing);
488 long ind2(long arg);
489 
490 long ind_fact_2(long arg);
491 long twoPow(long arg);
492 ideal createG0();
493 #endif
494 int redLazy (LObject* h,kStrategy strat);
495 int redHomog (LObject* h,kStrategy strat);
496 int redSig (LObject* h,kStrategy strat);
497 //adds hSig to be able to check with F5's criteria when entering pairs!
498 void enterpairsSig (poly h, poly hSig, int from, int k, int ec, int pos,kStrategy strat, int atR = -1);
499 void enterpairs (poly h, int k, int ec, int pos,kStrategy strat, int atR = -1);
500 void entersets (LObject h);
501 void pairs ();
502 BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1, bool enterTstrong = FALSE);
503 void message (int i,int* reduc,int* olddeg,kStrategy strat,int red_result);
504 void messageStat (int hilbcount,kStrategy strat);
505 #ifdef KDEBUG
506 void messageSets (kStrategy strat);
507 #else
508 #define messageSets(s) do {} while (0)
509 #endif
510 
511 void initEcartNormal (TObject* h);
512 void initEcartBBA (TObject* h);
513 void initS (ideal F, ideal Q,kStrategy strat);
514 void initSL (ideal F, ideal Q,kStrategy strat);
515 void initSLSba (ideal F, ideal Q,kStrategy strat);
516 /*************************************************
517  * when initializing a new bunch of principal
518  * syzygies at the beginning of a new iteration
519  * step in a signature-based algorithm we
520  * compute ONLY the leading elements of those
521  * syzygies, NOT the whole syzygy
522  * NOTE: this needs to be adjusted for a more
523  * general approach on signature-based algorithms
524  ***********************************************/
525 void initSyzRules (kStrategy strat);
526 void updateS(BOOLEAN toT,kStrategy strat);
527 void enterSyz (LObject &p,kStrategy strat, int atT);
528 void enterT (LObject &p,kStrategy strat, int atT = -1);
529 void enterT_strong (LObject &p,kStrategy strat, int atT = -1);
530 void cancelunit (LObject* p,BOOLEAN inNF=FALSE);
531 void HEckeTest (poly pp,kStrategy strat);
532 void initBuchMoraCrit(kStrategy strat);
533 void initSbaCrit(kStrategy strat);
534 void initHilbCrit(ideal F, ideal Q, intvec **hilb,kStrategy strat);
535 void initBuchMoraPos(kStrategy strat);
536 void initSbaPos(kStrategy strat);
537 void initBuchMora (ideal F, ideal Q,kStrategy strat);
538 void initSbaBuchMora (ideal F, ideal Q,kStrategy strat);
539 void exitBuchMora (kStrategy strat);
540 void exitSba (kStrategy strat);
541 void updateResult(ideal r,ideal Q,kStrategy strat);
542 void completeReduce (kStrategy strat, BOOLEAN withT=FALSE);
543 void kFreeStrat(kStrategy strat);
544 void enterOnePairNormal (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);
545 void enterOnePairLift (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);
546 void enterOnePairSig (int i,poly p,poly pSig,int ecart, int isFromQ,kStrategy strat, int atR);
547 void chainCritNormal (poly p,int ecart,kStrategy strat);
548 void chainCritOpt_1 (poly,int,kStrategy strat);
549 void chainCritSig (poly p,int ecart,kStrategy strat);
550 BOOLEAN homogTest(polyset F, int Fmax);
551 BOOLEAN newHEdge(kStrategy strat);
552 BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat);
553 BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat);
554 KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
555 BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
556 BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
557 BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start);
558 BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start);
559 
560 /// returns index of p in TSet, or -1 if not found
561 int kFindInT(poly p, TSet T, int tlength);
562 
563 /// return -1 if no divisor is found
564 /// number of first divisor in T, otherwise
565 int kFindDivisibleByInT(const kStrategy strat, const LObject* L, const int start=0);
566 
567 /// return -1 if no divisor is found
568 /// number of first divisor in S, otherwise
569 int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject* L);
570 
571 int kFindNextDivisibleByInS(const kStrategy strat, int start,int max_ind, LObject* L);
572 TObject*
573 kFindDivisibleByInS(kStrategy strat, int pos, LObject* L, TObject *T,
574  long ecart = LONG_MAX);
575 
576 /***************************************************************
577  *
578  * stuff to be inlined
579  *
580  ***************************************************************/
581 
582 KINLINE TSet initT ();
583 KINLINE TObject** initR();
584 KINLINE unsigned long* initsevT();
589 
594 
595 // if exp bound is not violated, return TRUE and
596 // get m1 = LCM(LM(p1), LM(p2))/LM(p1)
597 // m2 = LCM(LM(p1), LM(p2))/LM(p2)
598 // return FALSE and m1 == NULL, m2 == NULL , otherwise
599 KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r,
600  poly &m1, poly &m2, const ring m_r);
601 #ifdef HAVE_RINGS
602 KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing,
603  poly &m1, poly &m2, poly &lcm, const ring taiRing);
604 #endif
605 #ifdef KDEBUG
606 // test strat
607 BOOLEAN kTest(kStrategy strat);
608 // test strat, and test that S is contained in T
609 BOOLEAN kTest_TS(kStrategy strat);
610 // test LObject
611 BOOLEAN kTest_L(LObject* L, ring tailRing = NULL,
612  BOOLEAN testp = FALSE, int lpos = -1,
613  TSet T = NULL, int tlength = -1);
614 // test TObject
615 BOOLEAN kTest_T(TObject* T, ring tailRing = NULL, int tpos = -1, char TN = '?');
616 // test set strat->SevS
617 BOOLEAN kTest_S(kStrategy strat);
618 #else
619 #define kTest(A) (TRUE)
620 #define kTest_TS(A) (TRUE)
621 #define kTest_T(T) (TRUE)
622 #define kTest_S(T) (TRUE)
623 #define kTest_L(T) (TRUE)
624 #endif
625 
626 
627 /***************************************************************
628  *
629  * From kstd2.cc
630  *
631  ***************************************************************/
632 poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing);
633 ideal bba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
634 ideal sba (ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat);
635 poly kNF2 (ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce);
636 ideal kNF2 (ideal F,ideal Q,ideal q, kStrategy strat, int lazyReduce);
637 void initBba(kStrategy strat);
638 void initSba(ideal F,kStrategy strat);
639 void f5c (kStrategy strat, int& olddeg, int& minimcnt, int& hilbeledeg,
640  int& hilbcount, int& srmax, int& lrmax, int& reduc, ideal Q,
641  intvec *w,intvec *hilb );
642 
643 /***************************************************************
644  *
645  * From kspoly.cc
646  *
647  ***************************************************************/
648 // Reduces PR with PW
649 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)
650 // Changes: PR
651 // Const: PW
652 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)
653 // If strat != NULL, tailRing is changed if reduction would violate exp bound
654 // of tailRing
655 // Returns: 0 everything ok, no tailRing change
656 // 1 tailRing has successfully changed (strat != NULL)
657 // 2 no reduction performed, tailRing needs to be changed first
658 // (strat == NULL)
659 // -1 tailRing change could not be performed due to exceeding exp
660 // bound of currRing
661 int ksReducePoly(LObject* PR,
662  TObject* PW,
663  poly spNoether = NULL,
664  number *coef = NULL,
665  kStrategy strat = NULL);
666 
667 // Reduces PR with PW
668 // Assumes PR != NULL, PW != NULL, Lm(PW) divides Lm(PR)
669 // Changes: PR
670 // Const: PW
671 // If coef != NULL, then *coef is a/gcd(a,b), where a = LC(PR), b = LC(PW)
672 // If strat != NULL, tailRing is changed if reduction would violate exp bound
673 // of tailRing
674 // Returns: 0 everything ok, no tailRing change
675 // 1 tailRing has successfully changed (strat != NULL)
676 // 2 no reduction performed, tailRing needs to be changed first
677 // (strat == NULL)
678 // 3 no reduction performed, not sig-safe!!!
679 // -1 tailRing change could not be performed due to exceeding exp
680 // bound of currRing
681 int ksReducePolySig(LObject* PR,
682  TObject* PW,
683  long idx,
684  poly spNoether = NULL,
685  number *coef = NULL,
686  kStrategy strat = NULL);
687 
688 // Reduces PR at Current->next with PW
689 // Assumes PR != NULL, Current contained in PR
690 // Current->next != NULL, LM(PW) devides LM(Current->next)
691 // Changes: PR
692 // Const: PW
693 // Return: see ksReducePoly
694 int ksReducePolyTail(LObject* PR,
695  TObject* PW,
696  poly Current,
697  poly spNoether = NULL);
698 
699 KINLINE int ksReducePolyTail(LObject* PR, TObject* PW, LObject* Red);
700 
701 // Creates S-Poly of Pair
702 // Const: Pair->p1, Pair->p2
703 // Changes: Pair->p == S-Poly of p1, p2
704 // Assume: Pair->p1 != NULL && Pair->p2
705 void ksCreateSpoly(LObject* Pair, poly spNoether = NULL,
706  int use_buckets=0, ring tailRing=currRing,
707  poly m1 = NULL, poly m2 = NULL, TObject** R = NULL);
708 
709 /*2
710 * creates the leading term of the S-polynomial of p1 and p2
711 * do not destroy p1 and p2
712 * remarks:
713 * 1. the coefficient is 0 (nNew)
714 * 2. pNext is undefined
715 */
717 
718 
719 // old stuff
720 KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether = NULL);
721 KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether = NULL);
722 KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether = NULL, ring r = currRing);
723 KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r = currRing);
724 
725 /***************************************************************
726  *
727  * Routines related for ring changes during std computations
728  *
729  ***************************************************************/
730 // return TRUE and set m1, m2 to k_GetLcmTerms,
731 // if spoly creation of strat->P does not violate
732 // exponent bound of strat->tailRing
733 // FALSE, otherwise
735 #ifdef HAVE_RINGS
736 // return TRUE if gcdpoly creation of R[atR] and S[atS] does not violate
737 // exponent bound of strat->tailRing
738 // FALSE, otherwise
739 BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat);
740 poly preIntegerCheck(ideal F, ideal Q);
741 void postReduceByMon(LObject* h, kStrategy strat);
742 void finalReduceByMon(kStrategy strat);
743 #endif
744 // change strat->tailRing and adjust all data in strat, L, and T:
745 // new tailRing has larger exponent bound
746 // do nothing and return FALSE if exponent bound increase would result in
747 // larger exponent bound that that of currRing
749  LObject* L = NULL, TObject* T = NULL,
750  // take this as new_expbound: if 0
751  // new expbound is 2*expbound of tailRing
752  unsigned long new_expbound = 0);
753 // initiate a change of the tailRing of strat -- should be called
754 // right before main loop in bba
756 
757 /// Output some debug info about a given strategy
758 void kDebugPrint(kStrategy strat);
759 
760 // getting sb order for sba computations
761 ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1);
762 
763 KINLINE void clearS (poly p, unsigned long p_sev, int* at, int* k,
764  kStrategy strat);
765 
766 #include <kernel/GBEngine/kInline.h>
767 
768 /* shiftgb stuff */
769 #include <kernel/GBEngine/shiftgb.h>
770 
772 
774 
776 
777 void enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV);
778 
779 void initBuchMoraShift (ideal F,ideal Q,kStrategy strat);
780 
781 void enterOnePairManyShifts (int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV); // ok
782 
783 void enterOnePairSelfShifts (poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV);
784 
785 void enterOnePairShift (poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS, int uptodeg, int lV); // ok
786 
787 void enterpairsShift (poly h,int k,int ecart,int pos,kStrategy strat, int atR,int uptodeg, int lV);
788 
789 void initenterpairsShift (poly h,int k,int ecart,int isFromQ,kStrategy strat, int atR,int uptodeg, int lV);
790 
791 void updateSShift(kStrategy strat,int uptodeg,int lV);
792 
793 void initBbaShift(kStrategy strat);
794 
795 poly redtailBbaShift (LObject* L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize);
796 
797 int redFirstShift (LObject* h,kStrategy strat); // ok
798 
799 ideal freegb(ideal I, int uptodeg, int lVblock);
800 
801 ideal bbaShift(ideal F, ideal Q,intvec *w,intvec *hilb,kStrategy strat, int uptodeg, int lV);
802 // test syz strategy: // will be removed soon
803 extern int (*test_PosInT)(const TSet T,const int tl,LObject &h);
804 extern int (*test_PosInL)(const LSet set, const int length,
805  LObject* L,const kStrategy strat);
806 #endif
KINLINE TObject ** initR()
Definition: kInline.h:92
unsigned long * sevSig
Definition: kutil.h:320
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition: kutil.cc:617
void deleteHC(poly *p, int *e, int *l, kStrategy strat)
Definition: kutil.cc:310
int posInLRing(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4960
denominator_list_s * denominator_list
Definition: kutil.h:65
polyset sig
Definition: kutil.h:304
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:9869
int posInLSig(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4936
static number Copy(number a, const coeffs r)
Definition: flintcf_Q.cc:233
int nr
Definition: kutil.h:344
CFArray copy(const CFList &list)
write elements of list into an array
void initSba(ideal F, kStrategy strat)
Definition: kstd1.cc:1443
void entersets(LObject h)
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1028
void initSyzRules(kStrategy strat)
Definition: kutil.cc:6733
#define setmaxL
Definition: kutil.h:29
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:711
void initSbaCrit(kStrategy strat)
Definition: kutil.cc:8155
omBin_t * omBin
Definition: omStructs.h:12
int syzComp
Definition: kutil.h:352
void updateResult(ideal r, ideal Q, kStrategy strat)
Definition: kutil.cc:8644
void mu(int **points, int sizePoints)
BOOLEAN is_redundant
Definition: kutil.h:90
void initEcartNormal(TObject *h)
Definition: kutil.cc:1135
void enterOnePairSelfShifts(poly qq, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10335
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
Definition: kutil.cc:6274
int syzmax
Definition: kutil.h:347
BOOLEAN is_normalized
Definition: kutil.h:84
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1082
kBucket_pt bucket
Definition: kutil.h:188
poly kHEdge
Definition: kutil.h:325
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4371
pLDegProc pOrigLDeg_TailRing
Definition: kutil.h:295
class sLObject LObject
Definition: kutil.h:60
BOOLEAN length_pLength
Definition: kutil.h:377
TObject * TSet
Definition: kutil.h:61
int posInL15(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5500
wlen_set lenSw
Definition: kutil.h:316
#define kTest_S(T)
Definition: kutil.h:622
int sgn(const Rational &a)
Definition: GMPrat.cc:437
#define FALSE
Definition: auxiliary.h:140
BOOLEAN noTailReduction
Definition: kutil.h:368
unsigned checked
Definition: kutil.h:190
Compatiblity layer for legacy polynomial operations (over currRing)
int * S_2_R
Definition: kutil.h:340
return P p
Definition: myNF.cc:203
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L=NULL, TObject *T=NULL, unsigned long new_expbound=0)
Definition: kutil.cc:9357
f
Definition: cfModGcd.cc:4022
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8531
void f5c(kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
Definition: kstd2.cc:2755
int ksReducePolySig(LObject *PR, TObject *PW, long idx, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:175
BOOLEAN syzCriterion(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:5672
poly redtailBbaShift(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
Definition: kutil.cc:10842
char news
Definition: kutil.h:390
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4618
poly preIntegerCheck(ideal F, ideal Q)
used for GB over ZZ: look for constant and monomial elements in the ideal background: any known const...
Definition: kutil.cc:9048
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
Definition: kstd2.cc:1321
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:202
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10692
char newt
Definition: kutil.h:391
void chainCritNormal(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:2447
poly ksCreateShortSpoly(poly p1, poly p2, ring tailRing)
Definition: kspoly.cc:566
BOOLEAN * NotUsedAxis
Definition: kutil.h:330
BEGIN_NAMESPACE_SINGULARXX const ring const ring tailRing
Definition: DebugPrint.h:30
BOOLEAN posInLDependsOnLength
Definition: kutil.h:379
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
Definition: kInline.h:964
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:930
BOOLEAN noetherSet
Definition: kutil.h:370
void enterOnePairManyShifts(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10260
int cv
Definition: kutil.h:359
void messageStat(int hilbcount, kStrategy strat)
Definition: kutil.cc:6315
KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:914
BOOLEAN * pairtest
Definition: kutil.h:331
int & max_ind
Definition: myNF.cc:67
BOOLEAN z2homog
Definition: kutil.h:364
poly kNoether
Definition: kutil.h:326
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:1467
long int64
Definition: auxiliary.h:112
void initSbaPos(kStrategy strat)
Definition: kutil.cc:8433
void enterOnePairSig(int i, poly p, poly pSig, int ecart, int isFromQ, kStrategy strat, int atR)
char noClearS
Definition: kutil.h:392
#define TRUE
Definition: auxiliary.h:144
#define kTest(A)
Definition: kutil.h:619
poly kCreateZeroPoly(long exp[], long cabsind, poly *t_p, ring leadRing, ring tailRing)
Definition: kutil.cc:3554
pShallowCopyDeleteProc p_shallow_copy_delete
Definition: kutil.h:336
unsigned long * sevT
Definition: kutil.h:321
void enterpairsSig(poly h, poly hSig, int from, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:4040
poly pMove2CurrTail(poly p, kStrategy strat)
Definition: kutil.cc:10024
BOOLEAN kCheckStrongCreation(int atR, poly m1, int atS, poly m2, kStrategy strat)
Definition: kutil.cc:9028
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:3900
void initS(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:6379
g
Definition: cfModGcd.cc:4031
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat, int uptodeg, int lV)
Definition: kstd2.cc:3072
void initHilbCrit(ideal F, ideal Q, intvec **hilb, kStrategy strat)
Definition: kutil.cc:8068
int k
Definition: cfEzgcd.cc:93
P SetShortExpVector()
int(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kstd2.cc:98
void initBuchMora(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:8334
void enterT(LObject &p, kStrategy strat, int atT=-1)
Definition: kutil.cc:7807
#define Q
Definition: sirandom.c:25
long twoPow(long arg)
Definition: kutil.cc:3362
KINLINE unsigned long * initsevT()
Definition: kInline.h:97
void chainCritOpt_1(poly, int, kStrategy strat)
Definition: kutil.cc:2662
void initBbaShift(kStrategy strat)
Definition: kstd2.cc:3574
int redHomog(LObject *h, kStrategy strat)
Definition: kstd2.cc:519
void enterExtendedSpoly(poly h, kStrategy strat)
Definition: kutil.cc:3780
void initEcartBBA(TObject *h)
Definition: kutil.cc:1143
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define KINLINE
Definition: kutil.h:51
void HEckeTest(poly pp, kStrategy strat)
Definition: kutil.cc:436
int currIdx
Definition: kutil.h:313
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:45
int kFindDivisibleByInT(const kStrategy strat, const LObject *L, const int start=0)
return -1 if no divisor is found number of first divisor in T, otherwise
Definition: kstd2.cc:104
void exitBuchMora(kStrategy strat)
Definition: kutil.cc:8415
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
Definition: kutil.cc:9221
int minim
Definition: kutil.h:356
int posInLF5C(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5069
void initBuchMoraCrit(kStrategy strat)
Definition: kutil.cc:8088
int Bmax
Definition: kutil.h:350
ideal createG0()
Definition: kutil.cc:3683
poly pp
Definition: myNF.cc:296
int lastAxis
Definition: kutil.h:354
void initSLSba(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:6581
char completeReduce_retry
Definition: kutil.h:393
void chainCritSig(poly p, int ecart, kStrategy strat)
Definition: kutil.cc:2678
int HCord
Definition: kutil.h:353
void updateS(BOOLEAN toT, kStrategy strat)
Definition: kutil.cc:7341
poly t_p
Definition: kutil.h:76
pFDegProc pOrigFDeg
Definition: kutil.h:292
KINLINE void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r=currRing)
Definition: kInline.h:1112
BOOLEAN interpt
Definition: kutil.h:361
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4341
void kStratInitChangeTailRing(kStrategy strat)
Definition: kutil.cc:9460
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
long ind2(long arg)
Definition: kutil.cc:3335
int redRiloc(LObject *h, kStrategy strat)
Definition: kstd1.cc:355
poly redNFTail(poly h, const int sl, kStrategy strat)
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether=NULL, ring r=currRing)
Definition: kInline.h:1102
long ind_fact_2(long arg)
Definition: kutil.cc:3347
int lV
Definition: kutil.h:358
poly max
Definition: kutil.h:77
int LazyDegree
BOOLEAN fromT
Definition: kutil.h:369
const ring r
Definition: syzextra.cc:208
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4550
pLDegProc pOrigLDeg
Definition: kutil.h:293
int posInT0(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4302
BOOLEAN homog
Definition: kutil.h:362
void initEcartPairMora(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1157
void initBuchMoraPos(kStrategy strat)
Definition: kutil.cc:8240
Definition: intvec.h:16
long FDeg
Definition: kutil.h:79
int posInL17(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5558
#define kTest_TS(A)
Definition: kutil.h:620
int posInL110(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5419
static void Normalize(number &a, const coeffs r)
Definition: flintcf_Q.cc:347
int max_lower_index
Definition: kutil.h:314
int j
Definition: myNF.cc:70
void pairs()
intset fromQ
Definition: kutil.h:317
#define messageSets(s)
Definition: kutil.h:508
void enterOnePairNormal(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1532
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:923
int posInTSig(const TSet set, const int length, LObject &p)
void ksCreateSpoly(LObject *Pair, poly spNoether=NULL, int use_buckets=0, ring tailRing=currRing, poly m1=NULL, poly m2=NULL, TObject **R=NULL)
Definition: kspoly.cc:379
LObject * LSet
Definition: kutil.h:62
KINLINE TSet initT()
Definition: kInline.h:81
BOOLEAN enterOneStrongPoly(int i, poly p, int, int, kStrategy strat, int atR=-1, bool enterTstrong=FALSE)
Definition: kutil.cc:1395
int posInL0(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:4905
const ring R
Definition: DebugPrint.cc:36
void enterSSba(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:7676
ideal sba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
Definition: kstd2.cc:1879
#define kTest_L(T)
Definition: kutil.h:623
void kDebugPrint(kStrategy strat)
Output some debug info about a given strategy.
Definition: kutil.cc:9903
ideal freegb(ideal I, int uptodeg, int lVblock)
Definition: kstd2.cc:3413
void deleteInSSba(int i, kStrategy strat)
Definition: kutil.cc:994
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
Definition: kutil.cc:4197
int redRing(LObject *h, kStrategy strat)
Definition: kstd2.cc:409
int m
Definition: cfEzgcd.cc:119
KINLINE BOOLEAN arriRewDummy(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kInline.h:1172
LObject P
Definition: kutil.h:298
int HCord
Definition: kutil.cc:227
ideal M
Definition: kutil.h:301
unsigned sbaOrder
Definition: kutil.h:312
BOOLEAN update
Definition: kutil.h:371
int i
Definition: cfEzgcd.cc:123
poly tail
Definition: kutil.h:332
void initenterpairsShift(poly h, int k, int ecart, int isFromQ, kStrategy strat, int atR, int uptodeg, int lV)
Definition: kutil.cc:10726
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT=FALSE, BOOLEAN normalize=FALSE)
Definition: kstd2.cc:846
void enterOnePairLift(int i, poly p, int ecart, int isFromQ, kStrategy strat, int atR)
Definition: kutil.cc:1837
TObject ** R
Definition: kutil.h:338
poly lcm
Definition: kutil.h:187
polyset S
Definition: kutil.h:302
int posInSyz(const kStrategy strat, const poly sig)
Definition: kutil.cc:5041
BOOLEAN sugarCrit
Definition: kutil.h:367
intset lenS
Definition: kutil.h:315
int redFirstShift(LObject *h, kStrategy strat)
Definition: kstd2.cc:3447
static void Delete(number *a, const coeffs r)
Definition: flintcf_Q.cc:443
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4504
int tmax
Definition: kutil.h:348
void initBuchMoraShift(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:10176
void cleanT(kStrategy strat)
Definition: kutil.cc:505
int cp
Definition: kutil.h:345
void enterT_strong(LObject &p, kStrategy strat, int atT=-1)
Definition: kutil.cc:7891
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4676
int posInL11Ringls(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5227
int pLength
Definition: kutil.h:80
BOOLEAN newHEdge(kStrategy strat)
Definition: kutil.cc:8920
void initEcartPairBba(LObject *Lp, poly f, poly g, int ecartF, int ecartG)
Definition: kutil.cc:1150
poly sig
Definition: kutil.h:74
int int kStrategy strat
Definition: myNF.cc:68
void cancelunit(LObject *p, BOOLEAN inNF=FALSE)
Definition: kutil.cc:324
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:9778
Definition: kutil.h:70
static number Init(long i, const coeffs r)
Definition: flintcf_Q.cc:149
BOOLEAN kHEdgeFound
Definition: kutil.h:366
intset ecartS
Definition: kutil.h:305
void exitSba(kStrategy strat)
Definition: kutil.cc:8610
poly pMoveCurrTail2poly(poly p, kStrategy strat)
Definition: kutil.cc:10038
poly t_kHEdge
Definition: kutil.h:327
void reorderS(int *suc, kStrategy strat)
Definition: kutil.cc:4144
poly(* pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r, omBin dest_bin)
returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == de...
Definition: ring.h:52
s_poly_proc_t s_poly
Definition: kutil.h:296
void initBba(kStrategy strat)
Definition: kstd1.cc:1388
poly p2
Definition: kutil.h:184
int ksReducePolyTail(LObject *PR, TObject *PW, poly Current, poly spNoether=NULL)
Definition: kspoly.cc:494
LSet L
Definition: kutil.h:323
BOOLEAN LDegLast
Definition: kutil.h:375
#define NULL
Definition: omList.c:10
intvec * kHomW
Definition: kutil.h:334
poly * polyset
Definition: hutil.h:17
LSet B
Definition: kutil.h:324
int Lmax
Definition: kutil.h:349
int64 wlen_type
Definition: kutil.h:56
void enterSyz(LObject &p, kStrategy strat, int atT)
Definition: kutil.cc:8003
void enterpairs(poly h, int k, int ec, int pos, kStrategy strat, int atR=-1)
Definition: kutil.cc:3984
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
Definition: kInline.h:1127
void enterOnePairShift(poly q, poly p, int ecart, int isFromQ, kStrategy strat, int atR, int ecartq, int qisFromQ, int shiftcount, int ifromS, int uptodeg, int lV)
Definition: kutil.cc:10398
ring tailRing
Definition: kutil.h:341
void updateSShift(kStrategy strat, int uptodeg, int lV)
Definition: kutil.cc:10148
BOOLEAN homogTest(polyset F, int Fmax)
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:46
void completeReduce(kStrategy strat, BOOLEAN withT=FALSE)
Definition: kutil.cc:8797
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
Definition: kutil.cc:1111
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1145
void pNorm(poly p, const ring R=currRing)
Definition: polys.h:334
denominator_list next
Definition: kutil.h:67
BOOLEAN is_special
Definition: kutil.h:99
poly t_kNoether
Definition: kutil.h:329
omBin tailBin
Definition: kutil.h:343
BOOLEAN(* s_poly_proc_t)(kStrategy strat)
Definition: kstd1.h:14
ideal D
Definition: kutil.h:300
const CanonicalForm & w
Definition: facAbsFact.cc:55
strat ak
Definition: myNF.cc:321
BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5825
char overflow
Definition: kutil.h:394
intvec * kModW
Definition: kutil.h:333
BOOLEAN no_prod_crit
Definition: kutil.h:384
unsigned long * sevS
Definition: kutil.h:318
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:942
BOOLEAN arriRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5802
BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
Definition: kutil.cc:5746
void enterSBba(LObject &p, int atS, kStrategy strat, int atR=-1)
Definition: kutil.cc:7573
BOOLEAN posInLOldFlag
Definition: kutil.h:372
intset fromS
Definition: kutil.h:306
unsigned long * sevSyz
Definition: kutil.h:319
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
Definition: kutil.cc:9290
int posInL10(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd1.cc:1046
denominator_list DENOMINATOR_LIST
Definition: kutil.cc:81
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:295
int * intset
Definition: kutil.h:55
int posInT_EcartpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4579
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
Definition: kstd2.cc:250
polyset syz
Definition: kutil.h:303
void deleteInL(LSet set, int *length, int j, kStrategy strat)
Definition: kutil.cc:1049
int sl
Definition: kutil.h:346
int posInL13(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5465
BOOLEAN findMinLMPair(poly sig, unsigned long not_sevSig, kStrategy strat, int start)
TSet T
Definition: kutil.h:322
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
Definition: kutil.cc:8990
p exp[i]
Definition: DebugPrint.cc:39
int i_r2
Definition: kutil.h:189
wlen_type * wlen_set
Definition: kutil.h:57
omBin lmBin
Definition: kutil.h:342
void enterTShift(LObject p, kStrategy strat, int atT, int uptodeg, int lV)
Definition: kutil.cc:10799
poly redtail(poly p, int pos, kStrategy strat)
Definition: kutil.cc:6041
int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd2.cc:99
BOOLEAN syzCriterionInc(poly sig, unsigned long not_sevSig, kStrategy strat)
Definition: kutil.cc:5704
unsigned long sevSig
Definition: kutil.h:73
BOOLEAN use_buckets
Definition: kutil.h:373
END_NAMESPACE const void * p2
Definition: syzextra.cc:202
void kFreeStrat(kStrategy strat)
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize=FALSE)
Definition: kInline.h:1120
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
Definition: kstd2.cc:2599
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether=NULL)
Definition: kInline.h:1092
void wrp(poly p)
Definition: polys.h:281
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4805
#define kTest_T(T)
Definition: kutil.h:621
int strat_nr
Definition: kstdfac.cc:27
kBucketDestroy & P
Definition: myNF.cc:191
int LazyPass
Definition: kutil.h:351
static jList * T
Definition: janet.cc:37
polyrec * poly
Definition: hilb.h:10
static LSet initL(int nr=setmaxL)
Definition: kutil.h:411
int newIdeal
Definition: kutil.h:355
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin bin)
Definition: kInline.h:905
int redNF0(LObject *P, kStrategy strat)
ideal Shdl
Definition: kutil.h:299
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:9832
BOOLEAN prod_crit
Definition: kutil.h:195
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4313
static Poly * h
Definition: janet.cc:978
int int nonorm
Definition: myNF.cc:67
int BOOLEAN
Definition: auxiliary.h:131
int posInL11Ring(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5139
int redLazy(LObject *h, kStrategy strat)
Definition: kstd2.cc:957
kStrategy next
Definition: kutil.h:273
unsigned long sev
Definition: kutil.h:183
int redHoney(LObject *h, kStrategy strat)
Definition: kstd2.cc:1117
char redTailChange
Definition: kutil.h:389
pFDegProc pOrigFDeg_TailRing
Definition: kutil.h:294
int posInL11(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kutil.cc:5081
BOOLEAN is_sigsafe
Definition: kutil.h:95
int l
Definition: cfEzgcd.cc:94
int redSig(LObject *h, kStrategy strat)
Definition: kstd2.cc:678
END_NAMESPACE BEGIN_NAMESPACE_SINGULARXX ideal poly int int lazyReduce
Definition: myNF.cc:292
poly pCopyL2p(LObject h, kStrategy strat)
Definition: kutil.cc:10055
class sTObject TObject
Definition: kutil.h:59
ring tailRing
Definition: kutil.h:78
void initSL(ideal F, ideal Q, kStrategy strat)
Definition: kutil.cc:6482
poly p
Definition: kutil.h:75
intset syzIdx
Definition: kutil.h:309
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring taiRing)
Definition: kInline.h:1007
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether=NULL, number *coef=NULL, kStrategy strat=NULL)
Definition: kspoly.cc:38
ring sbaRing(kStrategy strat, const ring r=currRing, BOOLEAN complete=TRUE, int sgn=1)
Definition: kutil.cc:9487