18 #define PLURAL_INTERNAL_DECLARATIONS 1
37 #define SBA_INTERRED_START 0
38 #define SBA_TAIL_RED 1
39 #define SBA_PRODUCT_CRITERION 0
40 #define SBA_PRINT_ZERO_REDUCTIONS 0
41 #define SBA_PRINT_REDUCTION_STEPS 0
42 #define SBA_PRINT_OPERATIONS 0
43 #define SBA_PRINT_SIZE_G 0
44 #define SBA_PRINT_SIZE_SYZ 0
45 #define SBA_PRINT_PRODUCT_CRITERION 0
48 #if SBA_PRINT_REDUCTION_STEPS
49 VAR long sba_reduction_steps;
50 VAR long sba_interreduction_steps;
52 #if SBA_PRINT_OPERATIONS
53 VAR long sba_operations;
54 VAR long sba_interreduction_operations;
86 unsigned long not_sev = ~L->sev;
91 const unsigned long* sevT=strat->
sevT;
103 if (
j > strat->
tl)
return o;
124 if (
j > strat->
tl)
return o;
145 unsigned long not_sev = ~L->sev;
146 const unsigned long sevT0 = strat->
sevT[0];
147 number rest, orest,
mult;
150 const poly T0p = strat->
T[0].p;
157 #if defined(PDEBUG) || defined(PDIV_DEBUG)
179 const poly T0p = strat->
T[0].t_p;
181 const poly
p = L->t_p;
183 #if defined(PDEBUG) || defined(PDIV_DEBUG)
209 unsigned long not_sev = ~L->sev;
214 const unsigned long* sevT=strat->
sevT;
215 number rest, orest,
mult;
226 if (
j > strat->
tl)
return o;
227 #if defined(PDEBUG) || defined(PDIV_DEBUG)
258 if (
j > strat->
tl)
return o;
259 #if defined(PDEBUG) || defined(PDIV_DEBUG)
290 unsigned long not_sev = ~L->sev;
294 const unsigned long* sevT=strat->
sevT;
307 if (
j > strat->
tl)
return -1;
308 #if defined(PDEBUG) || defined(PDIV_DEBUG)
315 if (!(sevT[
j] & not_sev) &&
329 if (
j > strat->
tl)
return -1;
330 #if defined(PDEBUG) || defined(PDIV_DEBUG)
336 if (!(sevT[
j] & not_sev) &&
354 if (
j > strat->
tl)
return -1;
355 #if defined(PDEBUG) || defined(PDIV_DEBUG)
363 if (!(sevT[
j] & not_sev) &&
377 if (
j > strat->
tl)
return -1;
378 #if defined(PDEBUG) || defined(PDIV_DEBUG)
385 if (!(sevT[
j] & not_sev) &&
400 unsigned long not_sev = ~L->sev;
401 poly
p = L->GetLmCurrRing();
415 ende=
posInS(strat,*max_ind,
p,0)+1;
416 if (ende>(*max_ind)) ende=(*max_ind);
425 if (
j > ende)
return -1;
426 #if defined(PDEBUG) || defined(PDIV_DEBUG)
434 if ( !(strat->
sevS[
j] & not_sev) &&
448 if (
j > ende)
return -1;
449 #if defined(PDEBUG) || defined(PDIV_DEBUG)
456 if ( !(strat->
sevS[
j] & not_sev) &&
469 unsigned long not_sev = ~L->sev;
470 poly
p = L->GetLmCurrRing();
483 if (
j > ende)
return -1;
484 #if defined(PDEBUG) || defined(PDIV_DEBUG)
492 if ( !(strat->
sevS[
j] & not_sev) &&
506 if (
j > ende)
return -1;
507 #if defined(PDEBUG) || defined(PDIV_DEBUG)
514 if ( !(strat->
sevS[
j] & not_sev) &&
533 poly zeroPoly =
NULL;
534 unsigned long a = (
unsigned long)
pGetCoeff(
p);
537 int a_ind2 =
ind2(a);
541 for (
int i = 1;
i <= leadRing->N;
i++)
550 poly lead_mult =
p_ISet(1, tailRing);
551 if (
n_GetChar(leadRing->cf) <= k_ind2 + a_ind2)
553 int too_much = k_ind2 + a_ind2 -
n_GetChar(leadRing->cf);
555 zeroPoly =
p_ISet(a, tailRing);
556 for (
int i = 1;
i <= leadRing->N;
i++)
563 while ( (0 <
ind2(s_exp)) && (
ind2(s_exp) <= too_much) )
565 too_much = too_much -
ind2(s_exp);
569 for (
int j = 1;
j <= s_exp;
j++)
586 p_Setm(lead_mult, tailRing);
587 zeroPoly =
p_Mult_mm(zeroPoly, lead_mult, tailRing);
589 for (
int i = 1;
i <= leadRing->N;
i++)
642 if (
h->IsNull())
return 0;
643 if (strat->
tl<0)
return 1;
653 long reddeg =
h->GetpFDeg();
655 h->SetShortExpVector();
688 if (
h->GetLmTailRing() ==
NULL)
741 if (
h->GetLmTailRing() ==
NULL)
750 h->SetShortExpVector();
755 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
760 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
773 if (d >= (
long)strat->
tailRing->bitmask)
775 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
780 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
797 if (
h->IsNull())
return 0;
798 if (strat->
tl<0)
return 1;
809 long reddeg =
h->GetpFDeg();
811 h->SetShortExpVector();
833 if (
h->GetLmTailRing() ==
NULL)
846 if (
h->GetLmTailRing() ==
NULL)
852 h->SetShortExpVector();
857 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
862 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
875 if (d >= (
long)strat->
tailRing->bitmask)
877 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
882 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
904 if (strat->
tl<0)
return 1;
910 unsigned long not_sev;
915 h->SetShortExpVector();
917 h_p =
h->GetLmTailRing();
925 li = strat->
T[
j].pLength;
926 if (li<=0) li=strat->
T[
j].GetpLength();
943 if ((strat->
T[
i].pLength < li)
951 li = strat->
T[
i].pLength;
952 if (li<=0) li=strat->
T[
i].GetpLength();
973 #if SBA_PRINT_REDUCTION_STEPS
974 sba_interreduction_steps++;
976 #if SBA_PRINT_OPERATIONS
977 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
989 h_p =
h->GetLmTailRing();
1005 else if (
h->t_p!=
NULL)
1024 else if (
h->t_p!=
NULL)
1033 h->SetShortExpVector();
1045 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1046 if (at <= strat->Ll)
1048 #ifdef HAVE_SHIFTBBA
1057 int dummy=strat->
sl;
1064 Print(
" lazy: -> L%d\n",at);
1077 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1079 Red->HeadNormalize();
1113 if (strat->
tl<0)
return 1;
1119 PrintS(
"------- IN REDSIG -------\n");
1126 PrintS(
"---------------------------\n");
1129 int i,
j,at,pass, ii;
1132 unsigned long not_sev;
1137 h->SetShortExpVector();
1139 h_p =
h->GetLmTailRing();
1149 li = strat->
T[
j].pLength;
1150 if (li<=0) li=strat->
T[
j].GetpLength();
1167 if ((strat->
T[
i].pLength < li)
1175 li = strat->
T[
i].pLength;
1176 if (li<=0) li=strat->
T[
i].GetpLength();
1198 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
1199 PrintS(
"--------------------------------\n");
1206 PrintS(
"--------------------------------\n");
1207 printf(
"INDEX OF REDUCER T: %d\n",ii);
1210 #if SBA_PRINT_REDUCTION_STEPS
1212 sba_reduction_steps++;
1214 #if SBA_PRINT_OPERATIONS
1216 sba_operations +=
pLength(strat->
T[ii].p);
1223 Print(
"SigSAFE: %d\n",sigSafe);
1238 h_p =
h->GetLmTailRing();
1244 h->SetShortExpVector();
1256 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1257 if (at <= strat->Ll)
1259 int dummy=strat->
sl;
1267 Print(
" lazy: -> L%d\n",at);
1291 beforeredsig =
pCopy(
h->sig);
1293 if (strat->
tl<0)
return 1;
1299 Print(
"------- IN REDSIG -------\n");
1306 Print(
"---------------------------\n");
1309 int i,
j,at,pass, ii;
1312 unsigned long not_sev;
1317 h->SetShortExpVector();
1319 h_p =
h->GetLmTailRing();
1341 h->i_r1 = strat->
tl;
1344 if (
h->GetLmTailRing() ==
NULL)
1351 if(
pLtCmp(beforeredsig,
h->sig) == 1)
1374 li = strat->
T[
j].pLength;
1375 if (li<=0) li=strat->
T[
j].GetpLength();
1391 if ((strat->
T[
i].pLength < li)
1399 li = strat->
T[
i].pLength;
1400 if (li<=0) li=strat->
T[
i].GetpLength();
1422 Print(
"BEFORE REDUCTION WITH %d:\n",ii);
1423 Print(
"--------------------------------\n");
1430 Print(
"--------------------------------\n");
1431 printf(
"INDEX OF REDUCER T: %d\n",ii);
1459 #if SBA_PRINT_REDUCTION_STEPS
1461 sba_reduction_steps++;
1463 #if SBA_PRINT_OPERATIONS
1465 sba_operations +=
pLength(strat->
T[ii].p);
1472 Print(
"SigSAFE: %d\n",sigSafe);
1487 h_p =
h->GetLmTailRing();
1493 h->SetShortExpVector();
1505 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1506 if (at <= strat->Ll)
1508 int dummy=strat->
sl;
1516 Print(
" lazy: -> L%d\n",at);
1529 #define REDTAIL_CANONICALIZE 100
1533 p =
h = L->GetLmTailRing();
1535 return L->GetLmCurrRing();
1543 Ln.sevSig = L->sevSig;
1544 Ln.pLength = L->GetpLength() - 1;
1559 Ln.SetShortExpVector();
1565 With = &(strat->
T[
j]);
1570 if (With ==
NULL)
break;
1594 #if SBA_PRINT_REDUCTION_STEPS
1596 sba_reduction_steps++;
1598 #if SBA_PRINT_OPERATIONS
1600 sba_operations +=
pLength(With->p);
1610 pNext(
h) = Ln.LmExtractAndIter();
1613 }
while (!Ln.IsNull());
1616 if (Ln.IsNull())
goto all_done;
1617 if (! withT) With_s.Init(
currRing);
1624 pNext(
h) = Ln.LmExtractAndIter();
1641 return L->GetLmCurrRing();
1650 if (strat->
tl<0)
return 1;
1655 long reddeg =
h->GetpFDeg();
1657 unsigned long not_sev;
1659 h->SetShortExpVector();
1660 poly h_p =
h->GetLmTailRing();
1666 if (
j < 0)
return 1;
1668 li = strat->
T[
j].pLength;
1669 if (li<=0) li=strat->
T[
j].GetpLength();
1687 if ((strat->
T[
i].pLength < li)
1695 li = strat->
T[
i].pLength;
1696 if (li<=0) li=strat->
T[
i].GetpLength();
1718 #if SBA_PRINT_REDUCTION_STEPS
1719 sba_interreduction_steps++;
1721 #if SBA_PRINT_OPERATIONS
1722 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1734 h_p=
h->GetLmTailRing();
1751 else if (
h->t_p!=
NULL)
1770 else if (
h->t_p!=
NULL)
1779 h->SetShortExpVector();
1785 (strat->
Ll >= 0) && ((d > reddeg) || (pass > strat->
LazyPass)))
1788 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1789 if (at <= strat->Ll)
1792 #ifdef HAVE_SHIFTBBA
1801 int dummy=strat->
sl;
1814 else if (d != reddeg)
1816 if (d>=(
long)strat->
tailRing->bitmask)
1818 if (
h->pTotalDeg() >= (
long)strat->
tailRing->bitmask)
1823 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1844 if (strat->
tl<0)
return 1;
1848 int i,
j,at,pass,ei, ii, h_d;
1849 unsigned long not_sev;
1853 d = reddeg =
h->GetpFDeg() +
h->ecart;
1854 h->SetShortExpVector();
1856 h_p =
h->GetLmTailRing();
1863 if (
j < 0)
return 1;
1865 ei = strat->
T[
j].ecart;
1866 li = strat->
T[
j].pLength;
1867 if (li<=0) li=strat->
T[
j].GetpLength();
1885 if ((((strat->
T[
i].ecart < ei) && (ei>
h->ecart))
1886 || ((strat->
T[
i].ecart <=
h->ecart) && (strat->
T[
i].pLength < li)))
1894 ei = strat->
T[
i].ecart;
1895 li = strat->
T[
i].pLength;
1896 if (li<=0) li=strat->
T[
i].GetpLength();
1915 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
1933 Print(
"\nwith T[%d]:",ii);
1940 #if SBA_PRINT_REDUCTION_STEPS
1941 sba_interreduction_steps++;
1943 #if SBA_PRINT_OPERATIONS
1944 sba_interreduction_operations +=
pLength(strat->
T[ii].p);
1970 else if (
h->t_p!=
NULL)
1988 else if (
h->t_p!=
NULL)
1996 h->SetShortExpVector();
1998 h_d =
h->SetpFDeg();
2003 h->ecart = d-h_d+ei-
h->ecart;
2017 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2018 if (at <= strat->Ll)
2020 #ifdef HAVE_SHIFTBBA
2029 int dummy=strat->
sl;
2036 Print(
" degree jumped: -> L%d\n",at);
2042 else if (d > reddeg)
2044 if (d>=(
long)strat->
tailRing->bitmask)
2046 if (
h->pTotalDeg()+
h->ecart >= (
long)strat->
tailRing->bitmask)
2051 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
2073 #define REDNF_CANONICALIZE 60
2084 P.SetShortExpVector();
2190 P.SetShortExpVector();
2239 P.SetShortExpVector();
2320 P.SetShortExpVector();
2348 P.SetShortExpVector();
2387 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2410 withT = ! strat->
homog;
2415 #ifdef HAVE_TAIL_RING
2431 while (strat->
Ll >= 0)
2438 while (strat->
Ll >= 0)
2451 while ((strat->
Ll >= 0)
2452 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
2457 if (strat->
Ll<0)
break;
2462 strat->
P = strat->
L[strat->
Ll];
2492 else if (strat->
P.p1 ==
NULL)
2494 if (strat->
minim > 0)
2500 if ((strat->
P.p ==
NULL) && (strat->
P.t_p ==
NULL))
2508 &olddeg,&reduc,strat, red_result);
2511 red_result = strat->
red(&strat->
P,strat);
2521 if (red_result == 1)
2524 strat->
P.GetP(strat->
lmBin);
2533 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2545 strat->
P.pCleardenom();
2551 strat->
P.pContent();
2553 strat->
P.pCleardenom();
2557 strat->
P.pCleardenom();
2566 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
2578 if (strat->
minim==1)
2585 strat->
M->m[minimcnt]=strat->
P.p2;
2589 pNext(strat->
M->m[minimcnt])
2605 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2620 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
2628 if (strat->
s_poly(strat))
2633 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
2639 strat->
enterS(strat->
P, pos, strat, strat->
tl);
2643 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
2649 memset(&(strat->
P), 0,
sizeof(strat->
P));
2685 #ifdef HAVE_TAIL_RING
2707 for(
int i = 0;
i<=strat->
sl;
i++)
2742 return (strat->
Shdl);
2754 #if SBA_PRINT_ZERO_REDUCTIONS
2755 long zeroreductions = 0;
2757 #if SBA_PRINT_PRODUCT_CRITERION
2758 long product_criterion = 0;
2760 #if SBA_PRINT_SIZE_G
2762 int size_g_non_red = 0;
2764 #if SBA_PRINT_SIZE_SYZ
2768 #if SBA_PRINT_REDUCTION_STEPS
2769 sba_reduction_steps = 0;
2770 sba_interreduction_steps = 0;
2772 #if SBA_PRINT_OPERATIONS
2774 sba_interreduction_operations = 0;
2778 ring sRing, currRingOld;
2783 if (sRing!=currRingOld)
2802 dummy =
pCopy(F->m[0]);
2804 F->m[
i] = F->m[
i+1];
2825 dummy =
pCopy(F->m[0]);
2827 F->m[
i] = F->m[
i+1];
2845 for (
int i=0;
i<
sort->length();++
i)
2846 F->m[
i] = F1->m[(*
sort)[
i]-1];
2860 F->m[
j] = F->m[
j-1];
2874 #if SBA_INTERRED_START
2878 printf(
"SBA COMPUTATIONS DONE IN THE FOLLOWING RING:\n");
2880 printf(
"ordSgn = %d\n",
currRing->OrdSgn);
2883 int srmax,lrmax, red_result = 1;
2885 int hilbeledeg=1,hilbcount=0,minimcnt=0;
2899 reduc = olddeg = lrmax = 0;
2912 #ifdef HAVE_TAIL_RING
2930 strat->
enterS(strat->
L[strat->
Ll-(
i)], strat->
sl+1, strat, strat->
tl);
2940 while (strat->
Ll >= 0)
2942 if (strat->
Ll > lrmax) lrmax =strat->
Ll;
2972 f5c ( strat, olddeg, minimcnt, hilbeledeg, hilbcount, srmax,
2973 lrmax, reduc,
Q,
w, hilb );
2983 strat->
P = strat->
L[strat->
Ll];
2989 if (!strat->
rewCrit2(strat->
P.sig, ~strat->
P.sevSig, strat->
P.GetLmCurrRing(), strat, strat->
P.checked+1))
2993 PrintS(
"SIG OF NEXT PAIR TO HANDLE IN SIG-BASED ALGORITHM\n");
2994 PrintS(
"-------------------------------------------------\n");
2999 PrintS(
"-------------------------------------------------\n");
3034 else if (strat->
P.p1 ==
NULL)
3036 if (strat->
minim > 0)
3042 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
3050 PrintS(
"Poly before red: ");
3054 #if SBA_PRODUCT_CRITERION
3055 if (strat->
P.prod_crit)
3057 #if SBA_PRINT_PRODUCT_CRITERION
3058 product_criterion++;
3060 int pos =
posInSyz(strat, strat->
P.sig);
3067 red_result = strat->
red(&strat->
P,strat);
3070 red_result = strat->
red(&strat->
P,strat);
3086 strat->
P.p =
pNeg(strat->
P.p);
3087 strat->
P.sig =
pNeg(strat->
P.sig);
3090 if(strat->
P.sig !=
NULL)
3092 if(strat->
P.p !=
NULL)
3099 red_result =
redRing(&strat->
P,strat);
3104 strat->
P.sig =
NULL;
3108 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3124 if (red_result != 0)
3126 PrintS(
"Poly after red: ");
3128 pWrite(strat->
P.GetLmCurrRing());
3130 printf(
"%d\n",red_result);
3135 if(strat->
P.p !=
NULL)
3137 &olddeg,&reduc,strat, red_result);
3140 &olddeg,&reduc,strat, red_result);
3148 if (red_result == 1)
3151 strat->
P.GetP(strat->
lmBin);
3155 (strat->
P).FDeg = (strat->
P).pFDeg();
3167 int pos = strat->
sl+1;
3175 beforetailred =
pCopy(strat->
P.sig);
3181 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3189 strat->
P.pCleardenom();
3192 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3193 strat->
P.pCleardenom();
3200 strat->
P.p =
redtailSba(&(strat->
P),pos-1,strat, withT);
3209 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3215 if(strat->
P.sig ==
NULL ||
pLtCmp(beforetailred,strat->
P.sig) == 1)
3219 red_result =
redRing(&strat->
P,strat);
3228 strat->
enterS(strat->
P, 0, strat, strat->
tl);
3234 if(strat->
P.p ==
NULL)
3235 goto case_when_red_result_changed;
3241 for (
int jj = 0; jj<strat->
tl+1; jj++)
3245 strat->
T[jj].is_sigsafe =
FALSE;
3251 for (
int jj = 0; jj<strat->
tl+1; jj++)
3253 strat->
T[jj].is_sigsafe =
FALSE;
3263 if (strat->
minim==1)
3270 strat->
M->m[minimcnt]=strat->
P.p2;
3274 pNext(strat->
M->m[minimcnt])
3284 strat->
T[strat->
tl].is_sigsafe =
FALSE;
3298 strat->
enterS(strat->
P, pos, strat, strat->
tl);
3302 for (
int tk=0; tk<strat->
sl+1; tk++)
3323 for(
int ps=0;ps<strat->
sl+1;ps++)
3331 (strat->
syzmax)*
sizeof(
unsigned long),
3333 *
sizeof(
unsigned long));
3365 unsigned max_cmp =
IDELEMS(F);
3375 for (
int i=0;
i<strat->
sl; ++
i)
3392 for (
unsigned i=cmp+1;
i<=max_cmp; ++
i)
3395 for (
int j=0;
j<strat->
sl; ++
j)
3433 printf(
"---------------------------\n");
3434 Print(
" %d. ELEMENT ADDED TO GCURR:\n",strat->
sl+1);
3457 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
3460 if (strat->
sl>srmax) srmax = strat->
sl;
3464 case_when_red_result_changed:
3472 #if SBA_PRINT_ZERO_REDUCTIONS
3481 int pos =
posInSyz(strat, strat->
P.sig);
3485 Print(
"ADDING STUFF TO SYZ : ");
3498 memset(&(strat->
P), 0,
sizeof(strat->
P));
3504 printf(
"\nSigDrop!\n");
3506 printf(
"\nEnded with no SigDrop\n");
3512 if(strat->
P.sig !=
NULL)
3516 memset(&(strat->
P), 0,
sizeof(strat->
P));
3551 #ifdef HAVE_TAIL_RING
3567 #if SBA_PRINT_SIZE_SYZ
3569 size_syz = strat->
syzl;
3582 #if SBA_PRINT_SIZE_G
3597 for(;
k>=0 && (strat->
L[
k].p1 !=
NULL || strat->
L[
k].p2 !=
NULL);
k--)
3607 for(;
k>=0 && strat->
L[
k].p1 ==
NULL && strat->
L[
k].p2 ==
NULL;
k--)
3610 strat->
enterS(strat->
L[
k], strat->
sl+1, strat, strat->
tl);
3618 for(
k=strat->
sl;
k>=0;
k--)
3651 #if SBA_PRINT_SIZE_G
3655 printf(
"SIZE OF SHDL: %d\n",
IDELEMS(strat->
Shdl));
3659 printf(
" %d. ",oo+1);
3664 #if SBA_PRINT_ZERO_REDUCTIONS
3665 printf(
"----------------------------------------------------------\n");
3666 printf(
"ZERO REDUCTIONS: %ld\n",zeroreductions);
3669 #if SBA_PRINT_REDUCTION_STEPS
3670 printf(
"----------------------------------------------------------\n");
3671 printf(
"S-REDUCTIONS: %ld\n",sba_reduction_steps);
3673 #if SBA_PRINT_OPERATIONS
3674 printf(
"OPERATIONS: %ld\n",sba_operations);
3676 #if SBA_PRINT_REDUCTION_STEPS
3677 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3678 printf(
"INTERREDUCTIONS: %ld\n",sba_interreduction_steps);
3680 #if SBA_PRINT_OPERATIONS
3681 printf(
"INTERREDUCTION OPERATIONS: %ld\n",sba_interreduction_operations);
3683 #if SBA_PRINT_REDUCTION_STEPS
3684 printf(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - \n");
3685 printf(
"ALL REDUCTIONS: %ld\n",sba_reduction_steps+sba_interreduction_steps);
3686 sba_interreduction_steps = 0;
3687 sba_reduction_steps = 0;
3689 #if SBA_PRINT_OPERATIONS
3690 printf(
"ALL OPERATIONS: %ld\n",sba_operations+sba_interreduction_operations);
3691 sba_interreduction_operations = 0;
3694 #if SBA_PRINT_SIZE_G
3695 printf(
"----------------------------------------------------------\n");
3696 printf(
"SIZE OF G: %d / %d\n",size_g,size_g_non_red);
3700 #if SBA_PRINT_SIZE_SYZ
3701 printf(
"SIZE OF SYZ: %ld\n",size_syz);
3702 printf(
"----------------------------------------------------------\n");
3705 #if SBA_PRINT_PRODUCT_CRITERION
3706 printf(
"PRODUCT CRITERIA: %ld\n",product_criterion);
3707 product_criterion = 0;
3709 return (strat->
Shdl);
3733 #ifdef HAVE_SHIFTBBA
3885 #ifdef HAVE_SHIFTBBA
4028 int& hilbcount,
int& srmax,
int& lrmax,
int& reduc, ideal
Q,
4031 int Ll_old, red_result = 1;
4037 reduc = olddeg = lrmax = 0;
4042 while (strat->
tl >= 0)
4044 if(!strat->
T[strat->
tl].is_redundant)
4047 h.p = strat->
T[strat->
tl].p;
4048 h.tailRing = strat->
T[strat->
tl].tailRing;
4049 h.t_p = strat->
T[strat->
tl].t_p;
4088 while (strat->
Ll>Ll_old)
4090 strat->
P = strat->
L[strat->
Ll];
4094 PrintS(
"NEXT PAIR TO HANDLE IN INTERRED ALGORITHM\n");
4095 PrintS(
"-------------------------------------------------\n");
4099 printf(
"%d\n",strat->
tl);
4100 PrintS(
"-------------------------------------------------\n");
4133 else if (strat->
P.p1 ==
NULL)
4135 if (strat->
minim > 0)
4142 if (strat->
P.p ==
NULL && strat->
P.t_p ==
NULL)
4150 &olddeg,&reduc,strat, red_result);
4153 PrintS(
"Poly before red: ");
4157 red_result = strat->
red2(&strat->
P,strat);
4167 if (red_result == 1)
4170 strat->
P.GetP(strat->
lmBin);
4181 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4185 pos =
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4194 strat->
P.pCleardenom();
4197 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4198 strat->
P.pCleardenom();
4205 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4215 if (strat->
minim==1)
4222 strat->
M->m[minimcnt]=strat->
P.p2;
4226 pNext(strat->
M->m[minimcnt])
4239 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4242 PrintS(
"ELEMENT ADDED TO GCURR DURING INTERRED: ");
4246 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
4250 if (strat->
sl>srmax) srmax = strat->
sl;
4266 memset(&(strat->
P), 0,
sizeof(strat->
P));
4270 while (cc<strat->tl+1)
4272 strat->
T[cc].sig =
pOne();
4275 strat->
sig[cc] = strat->
T[cc].sig;
4276 strat->
sevSig[cc] = strat->
T[cc].sevSig;
4277 strat->
T[cc].is_sigsafe =
TRUE;
4285 for (
int cd=strat->
Ll;
cd>=0;
cd--)
4293 printf(
"\nAfter f5c sorting\n");
4294 for(
int i=0;
i<=strat->
sl;
i++)
4300 PrintS(
"------------------- STRAT S ---------------------\n");
4302 while (cc<strat->tl+1)
4306 printf(
"- - - - - -\n");
4309 PrintS(
"-------------------------------------------------\n");
4310 PrintS(
"------------------- STRAT T ---------------------\n");
4312 while (cc<strat->tl+1)
4316 printf(
"- - - - - -\n");
4319 PrintS(
"-------------------------------------------------\n");
4320 PrintS(
"------------------- STRAT L ---------------------\n");
4322 while (cc<strat->Ll+1)
4328 printf(
"- - - - - -\n");
4331 PrintS(
"-------------------------------------------------\n");
4332 printf(
"F5C DONE\nSTRAT SL: %d -- %d\n",strat->
sl, strat->
currIdx);
4339 #ifdef HAVE_SHIFTBBA
4344 int hilbeledeg=1,hilbcount=0,minimcnt=0;
4372 #ifdef HAVE_TAIL_RING
4388 while (strat->
Ll >= 0)
4395 while (strat->
Ll >= 0)
4408 while ((strat->
Ll >= 0)
4409 && (strat->
L[strat->
Ll].p1!=
NULL) && (strat->
L[strat->
Ll].p2!=
NULL)
4414 if (strat->
Ll<0)
break;
4419 strat->
P = strat->
L[strat->
Ll];
4449 else if (strat->
P.p1 ==
NULL)
4451 if (strat->
minim > 0)
4457 if ((strat->
P.p ==
NULL) && (strat->
P.t_p ==
NULL))
4465 &olddeg,&reduc,strat, red_result);
4468 red_result = strat->
red(&strat->
P,strat);
4478 if (red_result == 1)
4481 strat->
P.GetP(strat->
lmBin);
4490 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4502 strat->
P.pCleardenom();
4507 strat->
P.pCleardenom();
4511 strat->
P.pCleardenom();
4524 strat->
P.p =
redtailBba(&(strat->
P),pos-1,strat, withT);
4540 if (strat->
minim==1)
4547 strat->
M->m[minimcnt]=strat->
P.p2;
4551 pNext(strat->
M->m[minimcnt])
4565 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4570 if (hilb!=
NULL)
khCheck(
Q,
w,hilb,hilbeledeg,hilbcount,strat);
4578 if (strat->
s_poly(strat))
4583 int pos=
posInS(strat,strat->
sl,strat->
P.p,strat->
P.ecart);
4586 strat->
enterS(strat->
P, pos, strat, strat->
tl);
4592 else if (strat->
P.p1 ==
NULL && strat->
minim > 0)
4597 memset(&(strat->
P), 0,
sizeof(strat->
P));
4609 for (
int k = 0;
k <= strat->
sl; ++
k)
4612 for (
int j = 0;
j<=strat->
tl; ++
j)
4639 #ifdef HAVE_TAIL_RING
4646 WarnS(
"reduction with S is not yet supported by Letterplace");
4663 for(
int i = 0;
i<=strat->
sl;
i++)
4698 return (strat->
Shdl);
4702 #ifdef HAVE_SHIFTBBA
4718 #ifdef HAVE_SHIFTBBA
4721 if (
h->IsNull())
return 0;
4729 d =
h->GetpFDeg() +
h->ecart;
4732 h->SetShortExpVector();
4738 h->SetDegStuffReturnLDeg(strat->
LDegLast);
4743 strat->
T[
j].pNorm();
4769 h->SetShortExpVector();
4782 h->SetDegStuffReturnLDeg(strat->
LDegLast);
4792 if (strat->
T[
j].ecart <=
h->ecart)
4793 h->ecart = d -
h->GetpFDeg();
4795 h->ecart = d -
h->GetpFDeg() + strat->
T[
j].ecart -
h->ecart;
4797 d =
h->GetpFDeg() +
h->ecart;
4800 d =
h->SetDegStuffReturnLDeg(strat->
LDegLast);
4809 && ((d >= reddeg) || (pass > strat->
LazyPass)))
4814 at = strat->
posInL(strat->
L,strat->
Ll,
h,strat);
4815 if (at <= strat->Ll)
static int si_max(const int a, const int b)
CanonicalForm cd(bCommonDen(FF))
static CanonicalForm bound(const CFMatrix &M)
KINLINE poly kNoetherTail()
int(* red2)(LObject *L, kStrategy strat)
int(* posInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
pShallowCopyDeleteProc p_shallow_copy_delete
void(* enterS)(LObject &h, int pos, kStrategy strat, int atR)
char completeReduce_retry
void(* initEcart)(TObject *L)
int(* posInT)(const TSet T, const int tl, LObject &h)
int(* red)(LObject *L, kStrategy strat)
BOOLEAN(* rewCrit2)(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int start)
char posInLDependsOnLength
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
static FORCE_INLINE number n_EucNorm(number a, const coeffs r)
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
void sort(CFArray &A, int l=0)
quick sort A
void WerrorS(const char *s)
#define idDelete(H)
delete an ideal
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
BOOLEAN idInsertPolyOnPos(ideal I, poly p, int pos)
insert p into I on position pos
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
static BOOLEAN length(leftv result, leftv arg)
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
KINLINE poly redtailBbaBound(poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
BOOLEAN kbTest(kBucket_pt bucket)
Tests.
void kBucketDestroy(kBucket_pt *bucket_pt)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
const poly kBucketGetLm(kBucket_pt bucket)
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
void khCheck(ideal Q, intvec *w, intvec *hilb, int &eledeg, int &count, kStrategy strat)
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat)
int ksReducePolySig(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
int ksReducePolySigRing(LObject *PR, TObject *PW, long, poly spNoether, number *coef, kStrategy strat)
int ksReducePolyZ(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
int ksReducePolyGCD(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
ideal kStdShift(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, BOOLEAN rightGB)
ideal kInterRed(ideal F, ideal Q)
void initBba(kStrategy strat)
void initSba(ideal F, kStrategy strat)
int redRing_Z(LObject *h, kStrategy strat)
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
int redFirstShift(LObject *h, kStrategy strat)
int kFindSameLMInT_Z(const kStrategy strat, const LObject *L, const int start)
int kFindDivisibleByInT_Z(const kStrategy strat, const LObject *L, const int start)
int kFindDivisibleByInS(const kStrategy strat, int *max_ind, LObject *L)
return -1 if no divisor is found number of first divisor in S, otherwise
int kTestDivisibleByT0_Z(const kStrategy strat, const LObject *L)
tests if T[0] divides the leading monomial of L, returns -1 if not
poly redNFBound(poly h, int &max_ind, int nonorm, kStrategy strat, int bound)
#define REDNF_CANONICALIZE
poly kNF2(ideal F, ideal Q, poly q, kStrategy strat, int lazyReduce)
VAR int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
int redHoney(LObject *h, kStrategy strat)
int kFindNextDivisibleByInS(const kStrategy strat, int start, int max_ind, LObject *L)
int redHomog(LObject *h, kStrategy strat)
ideal sba(ideal F0, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
ideal bba(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
int redLazy(LObject *h, kStrategy strat)
int redSigRing(LObject *h, kStrategy strat)
poly redtailSba(LObject *L, int pos, kStrategy strat, BOOLEAN withT, BOOLEAN normalize)
KINLINE int ksReducePolyTailSig(LObject *PR, TObject *PW, LObject *Red, kStrategy strat)
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
int redSig(LObject *h, kStrategy strat)
void kDebugPrint(kStrategy strat)
void f5c(kStrategy strat, int &olddeg, int &minimcnt, int &hilbeledeg, int &hilbcount, int &srmax, int &lrmax, int &reduc, ideal Q, intvec *w, intvec *hilb)
VAR int(* test_PosInT)(const TSet T, const int tl, LObject &h)
poly kNF2Bound(ideal F, ideal Q, poly q, int bound, kStrategy strat, int lazyReduce)
int redRing(LObject *h, kStrategy strat)
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
ideal bbaShift(ideal F, ideal Q, intvec *w, intvec *hilb, kStrategy strat)
#define REDTAIL_CANONICALIZE
ideal rightgb(ideal F, ideal Q)
void initSbaPos(kStrategy strat)
void message(int i, int *reduc, int *olddeg, kStrategy strat, int red_result)
void initBuchMora(ideal F, ideal Q, kStrategy strat)
void enterSyz(LObject &p, kStrategy strat, int atT)
void enterT(LObject &p, kStrategy strat, int atT)
void enterTShift(LObject p, kStrategy strat, int atT)
BOOLEAN kTest(kStrategy strat)
BOOLEAN kTest_TS(kStrategy strat)
void enterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
void enterL(LSet *set, int *length, int *LSetmax, LObject p, int at)
long ind_fact_2(long arg)
BOOLEAN kTest_L(LObject *L, ring strat_tailRing, BOOLEAN testp, int lpos, TSet T, int tlength)
void enterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void redtailBbaAlsoLC_Z(LObject *L, int end_pos, kStrategy strat)
void initHilbCrit(ideal, ideal, intvec **hilb, kStrategy strat)
int posInSMonFirst(const kStrategy strat, const int length, const poly p)
void superenterpairsSig(poly h, poly hSig, int hFrom, int k, int ecart, int pos, kStrategy strat, int atR)
void initBuchMoraPos(kStrategy strat)
void initS(ideal F, ideal Q, kStrategy strat)
BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject *T, unsigned long expbound)
ring sbaRing(kStrategy strat, const ring r, BOOLEAN, int)
void postReduceByMon(LObject *h, kStrategy strat)
used for GB over ZZ: intermediate reduction by monomial elements background: any known constant eleme...
void enterpairsShift(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void exitBuchMora(kStrategy strat)
void messageStatSBA(int hilbcount, kStrategy strat)
int posInS(const kStrategy strat, const int length, const poly p, const int ecart_p)
void initSyzRules(kStrategy strat)
void initSbaBuchMora(ideal F, ideal Q, kStrategy strat)
BOOLEAN kCheckSpolyCreation(LObject *L, kStrategy strat, poly &m1, poly &m2)
void cleanT(kStrategy strat)
int posInSyz(const kStrategy strat, poly sig)
void replaceInLAndSAndT(LObject &p, int tj, kStrategy strat)
void deleteHC(LObject *L, kStrategy strat, BOOLEAN fromNext)
void updateResult(ideal r, ideal Q, kStrategy strat)
void superenterpairs(poly h, int k, int ecart, int pos, kStrategy strat, int atR)
void exitSba(kStrategy strat)
TObject * kFindDivisibleByInS_T(kStrategy strat, int end_pos, LObject *L, TObject *T, long ecart)
void deleteInL(LSet set, int *length, int j, kStrategy strat)
void kStratInitChangeTailRing(kStrategy strat)
void initBuchMoraCrit(kStrategy strat)
void completeReduce(kStrategy strat, BOOLEAN withT)
void initBuchMoraPosRing(kStrategy strat)
void postReduceByMonSig(LObject *h, kStrategy strat)
void messageSets(kStrategy strat)
void deleteInS(int i, kStrategy strat)
BOOLEAN sbaCheckGcdPair(LObject *h, kStrategy strat)
int posInLF5CRing(const LSet set, int start, const int length, LObject *p, const kStrategy)
void initEcartBBA(TObject *h)
void enterSBbaShift(LObject &p, int atS, kStrategy strat, int atR)
void messageStat(int hilbcount, kStrategy strat)
int posInIdealMonFirst(const ideal F, const poly p, int start, int end)
void finalReduceByMon(kStrategy strat)
used for GB over ZZ: final reduction by constant elements background: any known constant element of i...
void enterSBba(LObject &p, int atS, kStrategy strat, int atR)
void initSbaCrit(kStrategy strat)
void cancelunit(LObject *L, BOOLEAN inNF)
static void kDeleteLcm(LObject *P)
static void nc_kBucketPolyRed_NF(kBucket_pt b, poly p, number *c)
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
#define __p_GetComp(p, r)
#define omRealloc0Size(addr, o_size, size)
#define TEST_OPT_INTSTRATEGY
#define SI_RESTORE_OPT1(A)
#define TEST_OPT_DEGBOUND
#define TEST_OPT_REDTHROUGH
#define TEST_OPT_REDTAIL_SYZ
#define TEST_OPT_CONTENTSB
#define TEST_OPT_NOT_BUCKETS
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
unsigned long p_GetShortExpVector(const poly p, const ring r)
poly p_NSet(number n, const ring r)
returns the poly representing the number n, destroys n
void pEnlargeSet(poly **p, int l, int increment)
static poly p_Add_q(poly p, poly q, const ring r)
static poly p_Mult_q(poly p, poly q, const ring r)
static void p_ExpVectorAdd(poly p1, poly p2, const ring r)
#define p_LmEqual(p1, p2, r)
static void p_SetExpV(poly p, int *ev, const ring r)
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
static void p_Setm(poly p, const ring r)
static int p_LmCmp(poly p, poly q, const ring r)
static BOOLEAN p_LmShortDivisibleBy(poly a, unsigned long sev_a, poly b, unsigned long not_sev_b, const ring r)
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
static void p_Delete(poly *p, const ring r)
static unsigned pLength(poly a)
static void p_GetExpV(poly p, int *ev, const ring r)
static poly p_Mult_mm(poly p, poly m, const ring r)
static poly p_LmDeleteAndNext(poly p, const ring r)
static poly p_Copy(poly p, const ring r)
returns a copy of p
void rChangeCurrRing(ring r)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Compatiblity layer for legacy polynomial operations (over currRing)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
#define pGetComp(p)
Component.
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
void pNorm(poly p, const ring R=currRing)
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
#define pCopy(p)
return a copy of the poly
ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
void PrintS(const char *s)
void Werror(const char *fmt,...)
void rWrite(ring r, BOOLEAN details)
void rDelete(ring r)
unconditionally deletes fields in r
static BOOLEAN rField_is_Ring(const ring r)
static BOOLEAN rField_is_Z(const ring r)
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static BOOLEAN rIsLPRing(const ring r)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
void id_DelDiv(ideal id, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*L...
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)