35 int* Components,
long* ShiftedComponents);
63 (*so).isNotMinimal =
NULL;
82 (*so).isNotMinimal =
NULL;
100 (*argso).syzind = -1;
102 (*argso).isNotMinimal =
NULL;
103 (*argso).length = -1;
104 (*argso).reference = -1;
116 while (k+kk<sPlength)
120 if (kk>0)
syCopyPair(&sPairs[k+kk],&sPairs[k]);
144 while (k+kk<*sPlength)
148 if (kk>0)
syCopyPair(&sPairs[k+kk],&sPairs[k]);
173 long c1, c2, cc1, cc2, ccc1, ccc2, ec1, ec2;
180 ec1 = p1->exp[
currRing->typ[1].data.syzcomp.place];
181 ec2 = p2->exp[
currRing->typ[1].data.syzcomp.place];
185 Warn(
"Shifted comp of p1 out of sync. should %d, is %d", ccc1, ec1);
190 Warn(
"Shifted comp of p2 out of sync. should %d, is %d", ccc2, ec2);
208 if (o1 > o2)
return 1;
209 if (o1 < o2)
return -1;
225 if (o1==o2)
return 0;
279 for (i=iv->
length()-1;i>=0;i--)
283 if ((j<0) || ((*iv)[
i]<
j))
311 (resPairs[0])[i].syz = (arg->m[(*iv)[
i]-1]);
312 arg->m[(*iv)[
i]-1] =
NULL;
327 (resPairs[0])[i].syz = arg->m[j];
329 (resPairs[0])[
i].order = (*iv)[
j];
333 if (iv!=
NULL)
delete iv;
343 long new_comps = 0, new_space,
max;
348 if (sc[i-1] + 1 < sc[i]) holes++;
366 assume(new_space < SYZ_SHIFT_BASE && new_space >= 4);
368 long* tc = (
long*)
omAlloc(n*
sizeof(
long));
373 if (sc[i-1] + 1 < sc[i])
375 tc[
i] = tc[i-1] + new_space;
389 assume(tc[i-1] + 1 <= tc[i]);
418 if (syzstr->
res[index] !=
NULL)
443 int till=(*syzstr->
Tl)[index-1];
446 if (Pairs[i].syz!=
NULL)
449 till=(*syzstr->
Tl)[index];
452 if (Pairs1[i].
p!=
NULL)
469 int i=
IDELEMS(syzstr->
res[index-1])+1,
j=0,
k,tc,orc,ie=realcomp-1;
475 int *H1=syzstr->
Howmuch[index-1];
484 if (realcomp==0) realcomp=1;
497 if (trind1[orc]>tc+1)
break;
498 else if (trind1[orc] == tc+1)
511 WerrorS(
"orderedRes to small");
522 if ((LONG_MAX - same_comp) <= shind[ie-1])
525 assume((LONG_MAX - same_comp) > shind[ie-1]);
531 assume(ie == 1 || shind[ie-1] > 0);
532 shind[ie] = shind[ie-1] + same_comp;
544 if ((same_comp && prev + 2 >= next) || (!same_comp && next - prev < 4))
549 assume((same_comp && prev + 2 < next) || (!same_comp && next - prev >= 4));
555 for (
k=ie;
k >
j+1;
k--) shind[
k] = shind[
k-1];
560 shind[j+1] = prev + 1;
561 assume(shind[j+1] + 1 < shind[j+2]);
567 shind[j+1] = prev + ((next - prev) >> 1);
568 assume (shind[j] + 1 < shind[j+1] && shind[j+1] + 1 < shind[j+2]);
596 trind[
k] = trind[
k-1];
597 trind[realcomp] =
j+1;
602 #ifdef OLD_PAIR_ORDER 604 int howmuch,
int index)
606 int i=howmuch-1,i1=0,
l,ll;
619 if (syzstr->
res[index+1]!=
NULL)
625 while ((
l<ll) && (!isDivisible))
629 isDivisible = isDivisible ||
645 spSpolyCreate(tso.p2, tso.p1,
NULL,spSpolyLoop_General);
655 int howmuch,
int index)
657 int i=howmuch-1,i1=0,i2,i3,
l,ll;
670 if (syzstr->
res[index+1]!=
NULL)
676 while ((l<ll) && (!isDivisible))
680 isDivisible = isDivisible ||
706 for (i1=0;i1<howmuch;i1++)
717 if (((*spl)[i1]>=0) && ((*spl)[i1]<(*spl)[i2]))
725 (*result)[i3] = i2+1;
744 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
748 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
long));
751 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
754 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
757 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
760 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
int));
762 (
IDELEMS(syzstr->
res[index])+1)*
sizeof(
unsigned long),
763 (
IDELEMS(syzstr->
res[index])+17)*
sizeof(
unsigned long));
774 int howmuch,
int index)
779 int * Hin=syzstr->
Howmuch[index-1];
792 if ((nextPairs==
NULL) || (howmuch==0))
return;
793 while ((k>0) && (syzstr->
res[index]->m[k-1]==
NULL)) k--;
794 while ((ks>0) && (syzstr->
res[index+1]->m[ks-1]==
NULL)) ks--;
795 spl1 =
syLinStrat(nextPairs,syzstr,howmuch,index);
800 tso = nextPairs[(*spl1)[
i]-1];
801 if ((tso.p1!=
NULL) && (tso.p2!=
NULL))
807 tso.syz =
pHead(tso.lcm);
877 need_reset =
syOrder(syzstr->
res[index]->m[k-1],syzstr,index,k);
882 tso.isNotMinimal =
p;
897 syzstr->
res[index+1]->m[ks] = tso.syz;
904 if (
syOrder(syzstr->
res[index+1]->m[ks],syzstr,index+1,ks+1))
908 nextPairs[(*spl1)[
i]-1] = tso;
926 while ((k>0) && (res->m[k-1]==
NULL)) k--;
927 while ((i<(*syzstr->
Tl)[index-1]) && (((sPairs)[i].syz==
NULL) ||
928 ((sPairs)[i].order<deg)))
930 if ((i>=(*syzstr->
Tl)[index-1]) || ((sPairs)[i].order>deg))
return;
931 while ((i<(*syzstr->
Tl)[index-1]) && (((sPairs)[i].syz==
NULL) ||
932 ((sPairs)[i].order==deg)))
934 if ((sPairs)[i].syz!=
NULL)
937 while ((
j>=0) && (res->m[
j]!=
NULL) &&
938 ((sPairs)[i].syz!=
NULL))
952 if ((sPairs)[
i].syz !=
NULL)
961 if ((sPairs)[i].isNotMinimal==
NULL)
970 res->m[
k] =
syRedtail((sPairs)[i].syz,syzstr,index);
971 (sPairs)[i].syzind = k;
976 if (
syOrder(res->m[k-1],syzstr,index,k))
981 (sPairs)[
i].syzind = -1;
992 int ll,
k,no=(*so).order,sP=*sPlength,
i;
994 if ((sP==0) || (sPairs[sP-1].order<=no))
1005 if ((sPairs[an].order<=no) && (sPairs[an+1].order>no))
1010 else if ((sPairs[en].order<=no) && (sPairs[en+1].order>no))
1015 else if (sPairs[an].order>no)
1022 PrintS(
"Hier ist was faul!\n");
1027 if (sPairs[i].order <= no)
1033 for (k=(*sPlength);k>ll;k--)
1044 if (*sPlength>=(*syzstr->
Tl)[index])
1047 for (ll=0;ll<(*syzstr->
Tl)[index];ll++)
1058 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1060 temp[ll].reference = (syzstr->
resPairs[
index])[ll].reference;
1064 (*syzstr->
Tl)[index] += 16;
1079 int first,pos,jj,j1;
1085 while ((k>0) && (rs[k-1]==
NULL)) k--;
1086 if (newEl>=k)
return;
1091 ideal nP=
idInit(k,syzstr->
res[index]->rank);
1094 for (j=newEl;j<
k;j++)
1099 for (i=first;i<pos;i++)
1132 for (i=first;i<pos;i++)
1137 if (
l>=(*syzstr->
Tl)[index])
1139 temp = (
SSet)
omAlloc0(((*syzstr->
Tl)[index]+16)*
sizeof(SObject));
1140 for (ll=0;ll<(*syzstr->
Tl)[index];ll++)
1151 temp[ll].isNotMinimal = (syzstr->
resPairs[
index])[ll].isNotMinimal;
1155 (*syzstr->
Tl)[index] += 16;
1158 tso.lcm = p = nPm[ii];
1169 tso.order += (*syzstr->
cw)[jj-1];
1176 tso.isNotMinimal =
NULL;
1187 int *howmuch,
int * actdeg,
int an,
int en)
1189 int newdeg=*actdeg,newindex=-1,
i,t,sldeg;
1197 if (resPairs[*index]!=
NULL)
1199 sldeg = (*actdeg)+*
index;
1203 while ((
i<(*syzstr->
Tl)[*index]))
1205 if ((resPairs[*index])[
i].
lcm!=
NULL)
1207 if ((resPairs[*index])[
i].order == sldeg)
1209 result = &(resPairs[*
index])[
i];
1213 && ((resPairs[*
index])[
i].order == sldeg))
1228 if ((resPairs[*index])[
i].syz!=
NULL)
1230 if ((resPairs[*index])[
i].order == sldeg)
1232 result = &(resPairs[*
index])[
i];
1235 while ((
i<(*syzstr->
Tl)[*
index]) && ((resPairs[*index])[
i].syz!=
NULL)
1236 && ((resPairs[*index])[
i].order == *actdeg))
1254 if (resPairs[*index]!=
NULL)
1260 if (((resPairs[*index])[
i].lcm!=
NULL) ||
1261 ((resPairs[*index])[
i].syz!=
NULL))
1263 if ((resPairs[*index])[
i].order > t)
1264 t = (resPairs[*index])[
i].order;
1266 if ((t>*actdeg+*index) && ((newdeg==*actdeg) || (t<newdeg+*index)))
1307 int *howmuch,
int * actdeg,
int mindeg)
1436 while ((j<length) && (
res[j]!=
NULL))
1438 Print(
"In module %d: \n",j);
1451 Print(
"%d elements of degree %ld\n",i,deg);
1472 for (
int i=0;
i<init;
i++)
1483 syzstr->
sev[
index] = (
unsigned long*)
omAlloc0(init*
sizeof(
unsigned long));
1489 while ((result>0) && (syzstr->
res[index]->m[result-1]==
NULL)) result--;
1508 for (i=0;i<syzstr->
length;i++)
1524 for (i=0;i<syzstr->
length;i++)
1540 for (i=0;i<syzstr->
length;i++)
1555 for (i=0;i<syzstr->
length;i++)
1557 for (j=0;j<(*syzstr->
Tl)[i];j++)
1603 if (syzstr->
res[i]->m[j]!=
NULL)
1633 delete syzstr->
betti;
1660 ring origR=syzstr->
syRing;
1664 for (i=length-1;i>0;i--)
1671 while ((j>0) && (res[i-1]->
m[j-1]==
NULL)) j--;
1673 ri1 = totake[i-1]->m;
1674 for (j=
IDELEMS(res[i])-1;j>=0;j--)
1719 fullres[i-1]->m[
j] = q;
1727 for (j=
IDELEMS(res[i])-1;j>=0;j--)
1741 fullres[i-1] =
idCopy(res[i]);
1744 fullres[i-1] = res[
i];
1748 for (j=
IDELEMS(fullres[i-1])-1;j>=0;j--)
1777 for(i=weights->
length()-1; i>=0; i--)
1780 if ((*weights)[
i]!=(*(syzstr->
weights[0]))[
i])
1796 const int length = syzstr->
length;
1798 if ((fullres==
NULL) && (minres==
NULL))
1814 result =
syBetti(fullres,length,&dummy,weights,minim,row_shift);
1816 result =
syBetti(minres,length,&dummy,weights,minim,row_shift);
1849 WerrorS(
"No resolution found");
1853 while ((i>0) && (r[i-1]==
NULL)) i--;
1868 while ((l>0) && (rP[l-1]==
NULL)) l--;
1869 if (l==0)
return -1;
1874 while ((i<(*syzstr->
Tl)[l]) &&
1875 ((rP[l][i].lcm!=
NULL) || (rP[l][i].syz!=
NULL)) &&
1876 (rP[l][i].isNotMinimal!=
NULL))
1880 if ((i<(*syzstr->
Tl)[l]) &&
1881 ((rP[l][i].lcm!=
NULL) || (rP[l][i].syz!=
NULL)) &&
1882 (rP[l][i].isNotMinimal==
NULL))
1952 PrintS(
"No resolution defined\n");
1958 if (resolution==
NULL)
1965 (*resolution)[0] = syzstr->
res[1]->rank;
1967 while ((k<syzstr->length) && (rP[k]!=
NULL))
1970 while ((j<(*syzstr->
Tl)[k]) &&
1971 ((rP[k][j].lcm!=
NULL) || (rP[k][j].syz!=
NULL)))
1973 if (rP[k][j].isNotMinimal==
NULL)
1974 ((*resolution)[k+1])++;
1992 while ((k<syzstr->length) && (rr[k]!=
NULL))
1994 (*resolution)[k+1] =
idSize(rr[k]);
2005 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
2007 Print(
"%d",(*resolution)[k]);
2015 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
2018 if (((k+1)>=resolution->
length()) || ((*resolution)[(k+1)]==0))
2029 if ((k>=resolution->
length()) || ((*resolution)[
k]==0))
2039 PrintS(
"resolution not minimized yet");
2052 if (toStrip==
NULL)
return p;
2086 result = pp =
pHead(p);
2113 while ((ii<ordn->length()) && ((*ordn)[ii]!=-1) &&
2114 (sPairs[(*ordn)[ii]].syzind!=toMin))
2121 if (sPairs[
i].isNotMinimal!=
NULL)
2125 pisN = sPairs[
i].isNotMinimal;
2163 int ii=0,
i,tc,lp,ltS=-1;
2170 while ((ii<ordn->length()) && ((*ordn)[ii]!=-1) &&
2171 (sPairs[(*ordn)[ii]].syzind!=toMin))
2178 if (sPairs[
i].isNotMinimal!=
NULL)
2182 tc =
pGetComp(sPairs[i].isNotMinimal);
2216 for (i=0;i<length;i++)
2222 changes =
new intvec(rj+1,1,-1);
2223 while ((rj>0) && (ri->m[rj-1]==
NULL)) rj--;
2227 if (ri->m[j+k]!=
NULL)
2229 ri->m[
j] = ri->m[j+
k];
2230 (*changes)[j+k+1] = j+1;
2238 for (jj=j;jj<rj;jj++)
2243 for (j=
IDELEMS(ri)-1;j>=0;j--)
2269 for (
int i=(*syzstr->
Tl)[index-1]-1;
i>=0;
i--)
2273 (*result)[syzstr->
resPairs[index-1][
i].syzind+1] = 1;
2287 int i,
j=0,
k=-1,
l,ii;
2292 for(i=0;i<length;i++)
2294 if (sPairs[i].syzind>
k)
2298 l = sPairs[
i].syzind;
2303 if (sPairs[i].syzind<
l)
2305 l = sPairs[
i].syzind;
2332 tres[0] = syzstr->
res[1];
2343 for (index=syzstr->
length-1;index>0;index--)
2355 i1 = (*syzstr->
Tl)[index];
2360 if ((sPairs[i].isNotMinimal==
NULL) && (sPairs[i].
lcm!=
NULL))
2362 l = sPairs[
i].syzind;
2364 tres[index+1]->m[
l] =
2379 for (i=(*syzstr->
Tl)[0]-1;i>=0;i--)
2381 if (sPairs[i].syzind>=0)
2383 tres[1]->m[sPairs[
i].syzind] =
pCopy(syzstr->
res[1]->m[sPairs[i].syzind]);
2466 for (i=0;i<=arg->rank;i++)
2478 if (temp->m[i]!=
NULL)
2481 if (j<actdeg) actdeg =
j;
2498 syzstr->
sev = (
unsigned long **)
omAlloc0((*length+1)*
sizeof(
unsigned long *));
2505 while (nextPairs!=
NULL)
2527 if (
index<(*length)-1)
2538 if (origR != syzstr->
syRing)
2592 syzstr->
length = maxlength;
2605 for (i=0;i<=arg->rank;i++)
2612 syzstr->
Tl =
new intvec(maxlength);
2617 if (temp->m[i]!=
NULL)
2620 if (j<actdeg) actdeg =
j;
2640 syzstr->
sev = (
unsigned long **)
omAlloc0((maxlength+1)*
sizeof(
unsigned long *));
2650 while (nextPairs!=
NULL)
2672 if (
index<(maxlength-1))
2682 if (origR != syzstr->
syRing)
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
#define omRealloc0Size(addr, o_size, size)
static intvec * syLinStrat(SSet nextPairs, syStrategy syzstr, int howmuch, int index)
void syKillEmptyEntres(resolvente res, int length)
static void syCreateNewPairs(syStrategy syzstr, int index, int newEl)
intvec * syBettiOfComputation(syStrategy syzstr, BOOLEAN minim, int *row_shift, intvec *weights)
int lcm(unsigned long *l, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
void kBucketInit(kBucket_pt bucket, poly lm, int length)
void syEnlargeFields(syStrategy syzstr, int index)
static SSet syChosePairsPutIn(syStrategy syzstr, int *index, int *howmuch, int *actdeg, int an, int en)
poly prCopyR(poly p, ring src_r, ring dest_r)
#define idDelete(H)
delete an ideal
syStrategy syCopy(syStrategy syzstr)
int syDim(syStrategy syzstr)
Compatiblity layer for legacy polynomial operations (over currRing)
#define omMemcpyW(p1, p2, l)
number kBucketPolyRed(kBucket_pt bucket, poly p1, int l1, poly spNoether)
void syInitializePair(SObject *so)
void syMinimizeResolvente(resolvente res, int length, int first)
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
poly prMoveR(poly &p, ring src_r, ring dest_r)
poly syRedtail(poly p, syStrategy syzstr, int index)
#define omFreeSize(addr, size)
const poly kBucketGetLm(kBucket_pt bucket)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
intvec * ivCopy(const intvec *o)
static void syRedNextPairs(SSet nextPairs, syStrategy syzstr, int howmuch, int index)
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
resolvente syReorder(resolvente res, int length, syStrategy syzstr, BOOLEAN toCopy, resolvente totake)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
static resolvente syReadOutMinimalRes(syStrategy syzstr, BOOLEAN computeStd=FALSE)
void WerrorS(const char *s)
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
#define pLmDivisibleBy(a, b)
like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
#define SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE
kBucket_pt kBucketCreate(ring bucket_ring)
Creation/Destruction of buckets.
void syCopyPair(SObject *argso, SObject *imso)
#define pGetComp(p)
Component.
static int pLength(poly a)
long syReorderShiftedComponents(long *sc, int n)
void syPrint(syStrategy syzstr, const char *sn)
void syCompactifyPairSet(SSet sPairs, int sPlength, int first)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
#define pGetExp(p, i)
Exponent.
void rGetSComps(int **currComponents, long **currShiftedComponents, int *length, ring r)
static BOOLEAN syOrder(poly p, syStrategy syzstr, int index, int realcomp)
syStrategy syLaScala3(ideal arg, int *length)
#define pGetOrder(p)
Order.
void kBucketDestroy(kBucket_pt *bucket_pt)
#define pSortCompCorrect(p)
Assume: If considerd only as poly in any component of p (say, monomials of other components of p are ...
static int syChMin(intvec *iv)
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
#define TEST_OPT_NO_SYZ_MINIM
static int max(int a, int b)
#define pLmDivisibleByNoComp(a, b)
like pLmDivisibleBy, does not check components
static long pTotaldegree(poly p)
void syKillComputation(syStrategy syzstr, ring r)
static poly syMinimizeP1(int toMin, syStrategy syzstr, intvec *ordn, int index, intvec *toStrip)
int syInitSyzMod(syStrategy syzstr, int index, int init)
int sySize(syStrategy syzstr)
static int si_max(const int a, const int b)
void PrintS(const char *s)
static void syPrintEmptySpaces(int i)
void kBucket_Minus_m_Mult_p(kBucket_pt bucket, poly m, poly p, int *l, poly spNoether)
Bpoly == Bpoly - m*p; where m is a monom Does not destroy p and m assume (*l <= 0 || pLength(p) == *l...
SSet syChosePairs(syStrategy syzstr, int *index, int *howmuch, int *actdeg)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
static int syLengthInt(int i)
static void syRedGenerOfCurrDeg(syStrategy syzstr, int deg, int index)
static void syPrintEmptySpaces1(int i)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
static int syzcomp2dpc_test(poly p1, poly p2)
static int index(p_Length length, p_Ord ord)
void rChangeCurrRing(ring r)
void p_Setm_Syz(poly p, ring r, int *Components, long *ShiftedComponents)
static void p_Delete(poly *p, const ring r)
ideal idInit(int idsize, int rank)
initialise an ideal / module
static poly syStripOut(poly p, intvec *toStrip)
syStrategy syLaScala(ideal arg, int &maxlength, intvec *weights)
static poly syStripOutCopy(poly p, intvec *toStrip)
long ** ShiftedComponents
ring rAssure_dp_S(const ring r)
void pEnlargeSet(poly **p, int l, int increment)
void rDelete(ring r)
unconditionally deletes fields in r
void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R=currRing)
Splits *p into two polys: *q which consists of all monoms with component == comp and *p of all other ...
static SSet syChosePairsIH(syStrategy syzstr, int *index, int *howmuch, int *actdeg, int mindeg)
syStrategy syMinimize(syStrategy syzstr)
static void pResetSetm(poly p)
void syEnterPair(SSet sPairs, SObject *so, int *sPlength, int)
void pNorm(poly p, const ring R=currRing)
#define pInit()
allocates a new monomial and initializes everything to 0
long * currShiftedComponents
void syDeletePair(SObject *so)
SRes syInitRes(ideal arg, int *length, intvec *Tl, intvec *cw)
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
static int idSize(const ideal id)
Count the effective size of an ideal (without the trailing allocated zero-elements) ...
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
static intvec * syToStrip(syStrategy syzstr, int index)
static intvec * syOrdPairs(SSet sPairs, int length)
void syCompactify1(SSet sPairs, int *sPlength, int first)
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
void rChangeSComps(int *currComponents, long *currShiftedComponents, int length, ring r)
void kBucketTakeOutComp(kBucket_pt bucket, long comp, poly *r_p, int *l)
BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
void syResetShiftedComponents(syStrategy syzstr, int index, int hilb)
#define pCopy(p)
return a copy of the poly