My Project  UNKNOWN_GIT_VERSION
syz.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 
5 /*
6 * ABSTRACT: resolutions
7 */
8 
9 #include "kernel/mod2.h"
10 #include "misc/options.h"
11 #include "omalloc/omalloc.h"
12 #include "kernel/polys.h"
13 #include "kernel/GBEngine/kstd1.h"
14 #include "kernel/GBEngine/kutil.h"
16 #include "misc/intvec.h"
17 #include "coeffs/numbers.h"
18 #include "kernel/ideals.h"
19 #include "misc/intvec.h"
20 #include "polys/monomials/ring.h"
21 #include "kernel/GBEngine/syz.h"
22 #include "polys/prCopy.h"
23 
24 #include "polys/nc/sca.h"
25 
26 static intvec * syPrepareModComp(ideal arg,intvec ** w)
27 {
28  intvec *w1 = NULL;
29  int i;
30  BOOLEAN isIdeal=FALSE;
31 
32  if ((w==NULL) || (*w==NULL)) return w1;
33  int maxxx = (*w)->length();
34  if (maxxx==1)
35  {
36  maxxx = 2;
37  isIdeal = TRUE;
38  }
39  w1 = new intvec(maxxx+IDELEMS(arg));
40  if (!isIdeal)
41  {
42  for (i=0;i<maxxx;i++)
43  {
44  (*w1)[i] = (**w)[i];
45  }
46  }
47  for (i=maxxx;i<maxxx+IDELEMS(arg);i++)
48  {
49  if (arg->m[i-maxxx]!=NULL)
50  {
51  (*w1)[i] = p_FDeg(arg->m[i-maxxx],currRing);
52  if (pGetComp(arg->m[i-maxxx])!=0)
53  {
54  (*w1)[i]+=(**w)[pGetComp(arg->m[i-maxxx])-1];
55  }
56  }
57  }
58  delete (*w);
59  *w = new intvec(IDELEMS(arg)+1);
60  for (i=0;i<IDELEMS(arg);i++)
61  {
62  (**w)[i+1] = (*w1)[i+maxxx];
63  }
64  return w1;
65 }
66 
67 static void syDeleteAbove(ideal up, int k)
68 {
69  if (up!=NULL)
70  {
71  for (int i=0;i<IDELEMS(up);i++)
72  {
73  if (up->m[i]!=NULL)
74  pDeleteComp(&(up->m[i]),k+1);
75  }
76  }
77 }
78 
79 /*2
80 *minimizes the module mod and cancel superfluous syzygies
81 *from syz
82 */
83 static void syMinStep(ideal mod,ideal &syz,BOOLEAN final=FALSE,ideal up=NULL,
85 {
86  poly Unit1,Unit2,actWith;
87  int len,i,j,ModComp,m,k,l;
88  BOOLEAN searchUnit,existsUnit;
89 
90  if (TEST_OPT_PROT) PrintS("m");
91  if ((final) && (h==isHomog))
92  /*minim is TRUE, we are in the module: maxlength, maxlength <>0*/
93  {
94  ideal deg0=id_Jet(syz,0,currRing);
95  id_Delete(&syz,currRing);
96  idSkipZeroes(deg0);
97  syz=deg0;
98  }
99 /*--cancels empty entees and their related components above--*/
100  j = IDELEMS(syz);
101  while ((j>0) && (!syz->m[j-1])) j--;
102  k = 0;
103  while (k<j)
104  {
105  if (syz->m[k]!=NULL)
106  k++;
107  else
108  {
109  if (TEST_OPT_PROT) PrintS(".");
110  for (l=k;l<j-1;l++) syz->m[l] = syz->m[l+1];
111  syz->m[j-1] = NULL;
112  syDeleteAbove(up,k);
113  j--;
114  }
115  }
116 /*--searches for syzygies coming from superfluous elements
117 * in the module below--*/
118  searchUnit = TRUE;
119  int curr_syz_limit = rGetCurrSyzLimit(currRing);
120  BOOLEAN bHasGlobalOrdering=rHasGlobalOrdering(currRing);
121  BOOLEAN bField_has_simple_inverse=rField_has_simple_inverse(currRing);
122  while (searchUnit)
123  {
124  i=0;
125  j=IDELEMS(syz);
126  while ((j>0) && (syz->m[j-1]==NULL)) j--;
127  existsUnit = FALSE;
128  if (bHasGlobalOrdering)
129  {
130  while ((i<j) && (!existsUnit))
131  {
132  existsUnit = pVectorHasUnitB(syz->m[i],&ModComp);
133  i++;
134  }
135  }
136  else
137  {
138  int I=0;
139  l = 0;
140  len=0;
141  for (i=0;i<IDELEMS(syz);i++)
142  {
143  if (syz->m[i]!=NULL)
144  {
145  pVectorHasUnit(syz->m[i],&m, &l);
146  if ((len==0) ||((l>0) && (l<len)))
147  {
148  len = l;
149  ModComp = m;
150  I = i;
151  }
152  }
153  }
154 //Print("Laenge ist: %d\n",len);
155  if (len>0) existsUnit = TRUE;
156  i = I+1;
157  }
158  if (existsUnit)
159  {
160  i--;
161 //--takes out the founded syzygy--
162  if (TEST_OPT_PROT) PrintS("f");
163  actWith = syz->m[i];
164  if (!bField_has_simple_inverse) p_Cleardenom(actWith, currRing);
165 //Print("actWith: ");pWrite(actWith);
166  syz->m[i] = NULL;
167  for (k=i;k<j-1;k++) syz->m[k] = syz->m[k+1];
168  syz->m[j-1] = NULL;
169  syDeleteAbove(up,i);
170  j--;
171 //--makes Gauss alg. for the column ModComp--
172  Unit1 = pTakeOutComp(&(actWith), ModComp);
173 //PrintS("actWith now: ");pWrite(actWith);
174 //Print("Unit1: ");pWrite(Unit1);
175  k=0;
176 //Print("j= %d",j);
177  while (k<j)
178  {
179  if (syz->m[k]!=NULL)
180  {
181  Unit2 = pTakeOutComp(&(syz->m[k]), ModComp);
182 //Print("element %d: ",k);pWrite(syz->m[k]);
183 //PrintS("Unit2: ");pWrite(Unit2);
184  syz->m[k] = pMult(pCopy(Unit1),syz->m[k]);
185  syz->m[k] = pSub(syz->m[k],
186  pMult(Unit2,pCopy(actWith)));
187  if (syz->m[k]==NULL)
188  {
189  for (l=k;l<j-1;l++)
190  syz->m[l] = syz->m[l+1];
191  syz->m[j-1] = NULL;
192  j--;
193  syDeleteAbove(up,k);
194  k--;
195  }
196  }
197  k++;
198  }
199  pDelete(&actWith);
200  pDelete(&Unit1);
201 //--deletes superfluous elements from the module below---
202  pDelete(&(mod->m[ModComp-1 - curr_syz_limit]));
203  for (k=ModComp-1 - curr_syz_limit;k<IDELEMS(mod)-1;k++)
204  mod->m[k] = mod->m[k+1];
205  mod->m[IDELEMS(mod)-1] = NULL;
206  }
207  else
208  searchUnit = FALSE;
209  }
210  if (TEST_OPT_PROT) PrintLn();
211  idSkipZeroes(mod);
212  idSkipZeroes(syz);
213 }
214 
215 /*2
216 * make Gauss with the element elnum in the module component ModComp
217 * for the generators from - till
218 */
219 void syGaussForOne(ideal syz, int elnum, int ModComp,int from,int till)
220 {
221  int /*k,j,i,*/lu;
222  poly unit1,unit2;
223  poly actWith=syz->m[elnum];
224 
225  if (from<0) from = 0;
226  if ((till<=0) || (till>IDELEMS(syz))) till = IDELEMS(syz);
227  syz->m[elnum] = NULL;
229 /*--makes Gauss alg. for the column ModComp--*/
230  pTakeOutComp(&(actWith), ModComp, &unit1, &lu);
231  while (from<till)
232  {
233  poly tmp=syz->m[from];
234  if (/*syz->m[from]*/ tmp!=NULL)
235  {
236  pTakeOutComp(&(tmp), ModComp, &unit2, &lu);
237  tmp = pMult(pCopy(unit1),tmp);
238  syz->m[from] = pSub(tmp,
239  pMult(unit2,pCopy(actWith)));
240  }
241  from++;
242  }
243  pDelete(&actWith);
244  pDelete(&unit1);
245 }
246 static void syDeleteAbove1(ideal up, int k)
247 {
248  poly p/*,pp*/;
249  if (up!=NULL)
250  {
251  for (int i=0;i<IDELEMS(up);i++)
252  {
253  p = up->m[i];
254  while ((p!=NULL) && (pGetComp(p)==k))
255  {
256  /*
257  pp = pNext(p);
258  pNext(p) = NULL;
259  pDelete(&p);
260  p = pp;
261  */
262  pLmDelete(&p);
263  }
264  up->m[i] = p;
265  if (p!=NULL)
266  {
267  while (pNext(p)!=NULL)
268  {
269  if (pGetComp(pNext(p))==k)
270  {
271  /*
272  pp = pNext(pNext(p));
273  pNext(pNext(p)) = NULL;
274  pDelete(&pNext(p));
275  pNext(p) = pp;
276  */
277  pLmDelete(&pNext(p));
278  }
279  else
280  pIter(p);
281  }
282  }
283  }
284  }
285 }
286 /*2
287 *minimizes the resolution res
288 *assumes homogeneous or local case
289 */
290 static void syMinStep1(resolvente res, int length)
291 {
292  int i,j,k,index=0;
293  poly p;
294  intvec *have_del=NULL,*to_del=NULL;
295 
296  while ((index<length) && (res[index]!=NULL))
297  {
298 /*---we take out dependend elements from syz---------------------*/
299  if (res[index+1]!=NULL)
300  {
301  ideal deg0 = id_Jet(res[index+1],0,currRing);
302  ideal reddeg0 = kInterRedOld(deg0);
303  idDelete(&deg0);
304  have_del = new intvec(IDELEMS(res[index]));
305  for (i=0;i<IDELEMS(reddeg0);i++)
306  {
307  if (reddeg0->m[i]!=NULL)
308  {
309  j = pGetComp(reddeg0->m[i]);
310  pDelete(&(res[index]->m[j-1]));
311  /*res[index]->m[j-1] = NULL;*/
312  (*have_del)[j-1] = 1;
313  }
314  }
315  idDelete(&reddeg0);
316  }
317  if (index>0)
318  {
319 /*--- we search for units and perform Gaussian elimination------*/
320  j = to_del->length();
321  while (j>0)
322  {
323  if ((*to_del)[j-1]==1)
324  {
325  k = 0;
326  while (k<IDELEMS(res[index]))
327  {
328  p = res[index]->m[k];
329  while ((p!=NULL) && ((!pLmIsConstantComp(p)) || (pGetComp(p)!=j)))
330  pIter(p);
331  if ((p!=NULL) && (pLmIsConstantComp(p)) && (pGetComp(p)==j)) break;
332  k++;
333  }
334  if (k>=IDELEMS(res[index]))
335  {
336  PrintS("out of range\n");
337  }
339  if (res[index+1]!=NULL)
340  syDeleteAbove1(res[index+1],k+1);
341  (*to_del)[j-1] = 0;
342  }
343  j--;
344  }
345  }
346  if (to_del!=NULL) delete to_del;
347  to_del = have_del;
348  have_del = NULL;
349  index++;
350  }
351  if (TEST_OPT_PROT) PrintLn();
353  if (to_del!=NULL) delete to_del;
354 }
355 
357 {
358  int syzIndex=first;
359  intvec *dummy;
360 
361  if (syzIndex<1) syzIndex=1;
362  if ((syzIndex==1) && (!rIsPluralRing(currRing)) && (idHomModule(res[0],currRing->qideal,&dummy)))
363  {
365  delete dummy;
366  return;
367  }
368  while ((syzIndex<length-1) && (res[syzIndex]!=NULL) && (res[syzIndex+1]!=NULL))
369  {
370  syMinStep(res[syzIndex-1],res[syzIndex],FALSE,res[syzIndex+1]);
371  syzIndex++;
372  }
373  if (res[syzIndex]!=NULL)
374  syMinStep(res[syzIndex-1],res[syzIndex]);
375  if (!idIs0(res[0]))
376  idMinEmbedding(res[0],TRUE);
377 }
378 
379 /*2
380 * resolution of ideal/module arg, <=maxlength steps, (r[0..maxlength])
381 * no limitation in length if maxlength==0
382 * input:arg
383 * minim: TRUE means mres cmd, FALSE nres cmd.
384 * if *len!=0: module weights: weights[0]
385 * (and weights is defined:weights[0..len-1]
386 *
387 * output:resolvente r[0..length-1],
388 * module weights: weights[0..length-1]
389 */
390 resolvente syResolvente(ideal arg, int maxlength, int * length,
391  intvec *** weights, BOOLEAN minim)
392 {
393  BITSET save1;
394  SI_SAVE_OPT1(save1);
395  resolvente newres;
396  tHomog hom=isNotHomog;
397  intvec *w = NULL,**tempW;
398  int i,k,syzIndex = 0,j,rk_arg=si_max(1,(int)id_RankFreeModule(arg,currRing));
399  int Kstd1_OldDeg=Kstd1_deg;
400  BOOLEAN completeMinim;
401  BOOLEAN oldDegBound=TEST_OPT_DEGBOUND;
402  BOOLEAN setRegularity=TRUE;
403  int wlength=*length;
404 
405  if (maxlength!=-1) *length = maxlength+1;
406  else *length = 5;
407  if ((wlength!=0) && (*length!=wlength))
408  {
409  intvec **wtmp = (intvec**)omAlloc0((*length)*sizeof(intvec*));
410  wtmp[0]=(*weights)[0];
411  omFreeSize((ADDRESS)*weights,wlength*sizeof(intvec*));
412  *weights=wtmp;
413  }
414  resolvente res = (resolvente)omAlloc0((*length)*sizeof(ideal));
415 
416 /*--- initialize the syzygy-ring -----------------------------*/
417  ring origR = currRing;
418  ring syz_ring = rAssure_SyzComp(origR, TRUE); // will do rChangeCurrRing if needed
419  rSetSyzComp(rk_arg, syz_ring);
420 
421  if (syz_ring != origR)
422  {
423  rChangeCurrRing(syz_ring);
424  res[0] = idrCopyR_NoSort(arg, origR, syz_ring);
425  }
426  else
427  {
428  res[0] = idCopy(arg);
429  }
430 
431 /*--- creating weights for the module components ---------------*/
432  if ((weights!=NULL) && (*weights!=NULL)&& ((*weights)[0]!=NULL))
433  {
434  if (!idTestHomModule(res[0],currRing->qideal,(*weights)[0]))
435  {
436  WarnS("wrong weights given(1):"); (*weights)[0]->show();PrintLn();
437  idHomModule(res[0],currRing->qideal,&w);
438  w->show();PrintLn();
439  *weights=NULL;
440  }
441  }
442 
443  if ((weights==NULL) || (*weights==NULL) || ((*weights)[0]==NULL))
444  {
445  hom=(tHomog)idHomModule(res[0],currRing->qideal,&w);
446  if (hom==isHomog)
447  {
448  *weights = (intvec**)omAlloc0((*length)*sizeof(intvec*));
449  if (w!=NULL) (*weights)[0] = ivCopy(w);
450  }
451  }
452  else
453  {
454  if ((weights!=NULL) && (*weights!=NULL)&& ((*weights)[0]!=NULL))
455  {
456  w = ivCopy((*weights)[0]);
457  hom = isHomog;
458  }
459  }
460 
461 #ifdef HAVE_PLURAL
463  {
464 // quick solution; need theory to apply homog GB stuff for G-Algebras
465  hom = isNotHomog;
466  }
467 #endif // HAVE_PLURAL
468 
469  if (hom==isHomog)
470  {
471  intvec *w1 = syPrepareModComp(res[0],&w);
472  if (w!=NULL) { delete w;w=NULL; }
473  w = w1;
474  j = 0;
475  while ((j<IDELEMS(res[0])) && (res[0]->m[j]==NULL)) j++;
476  if (j<IDELEMS(res[0]))
477  {
478  if (p_FDeg(res[0]->m[j],currRing)!=pTotaldegree(res[0]->m[j]))
479  setRegularity = FALSE;
480  }
481  }
482  else
483  {
484  setRegularity = FALSE;
485  }
486 
487 /*--- the main loop --------------------------------------*/
488  while ((res[syzIndex]!=NULL) && (!idIs0(res[syzIndex])) &&
489  ((maxlength==-1) || (syzIndex<=maxlength)))
490  // (syzIndex<maxlength+(int)minim)))
491 /*--- compute one step more for minimizing-----------------*/
492  {
493  if (Kstd1_deg!=0) Kstd1_deg++;
494  if (syzIndex+1==*length)
495  {
496  newres = (resolvente)omAlloc0((*length+5)*sizeof(ideal));
497  tempW = (intvec**)omAlloc0((*length+5)*sizeof(intvec*));
498  for (j=0;j<*length;j++)
499  {
500  newres[j] = res[j];
501  if (*weights!=NULL) tempW[j] = (*weights)[j];
502  /*else tempW[j] = NULL;*/
503  }
504  omFreeSize((ADDRESS)res,*length*sizeof(ideal));
505  if (*weights != NULL) omFreeSize((ADDRESS)*weights,*length*sizeof(intvec*));
506  *length += 5;
507  res=newres;
508  *weights = tempW;
509  }
510 /*--- interreducing first -----------------------------------*/
511  if (syzIndex>0)
512  {
513  int rkI=id_RankFreeModule(res[syzIndex],currRing);
514  rSetSyzComp(rkI, currRing);
515  }
516  if(! TEST_OPT_NO_SYZ_MINIM )
517  if (minim || (syzIndex!=0))
518  {
519  ideal temp = kInterRedOld(res[syzIndex],currRing->qideal);
520  idDelete(&res[syzIndex]);
521  idSkipZeroes(temp);
522  res[syzIndex] = temp;
523  }
524 /*--- computing the syzygy modules --------------------------------*/
525  if ((currRing->qideal==NULL)&&(syzIndex==0)&& (!TEST_OPT_DEGBOUND))
526  {
527  res[/*syzIndex+*/1] = idSyzygies(res[0/*syzIndex*/],hom,&w,FALSE,setRegularity,&Kstd1_deg);
528  if ((!TEST_OPT_NOTREGULARITY) && (Kstd1_deg>0)
529  && (!rField_is_Ring(currRing))
531  }
532  else
533  {
534  res[syzIndex+1] = idSyzygies(res[syzIndex],hom,&w,FALSE);
535  }
536  completeMinim=(syzIndex!=maxlength) || (maxlength ==-1) || (hom!=isHomog);
537  syzIndex++;
538  if (TEST_OPT_PROT) Print("[%d]\n",syzIndex);
539 
540  if(! TEST_OPT_NO_SYZ_MINIM )
541  {
542  if ((minim)||(syzIndex>1))
543  syMinStep(res[syzIndex-1],res[syzIndex],!completeMinim,NULL,hom);
544  if (!completeMinim)
545  /*minim is TRUE, we are in the module: maxlength, maxlength <>0*/
546  {
547  idDelete(&res[syzIndex]);
548  }
549  }
550 /*---creating the iterated weights for module components ---------*/
551  if ((hom == isHomog) && (res[syzIndex]!=NULL) && (!idIs0(res[syzIndex])))
552  {
553 //Print("die %d Modulegewichte sind:\n",w1->length());
554 //w1->show();
555 //PrintLn();
556  int max_comp = id_RankFreeModule(res[syzIndex],currRing);
557  k = max_comp - rGetCurrSyzLimit(currRing);
558  assume(w != NULL);
559  if (w != NULL)
560  w->resize(max_comp+IDELEMS(res[syzIndex]));
561  else
562  w = new intvec(max_comp+IDELEMS(res[syzIndex]));
563  (*weights)[syzIndex] = new intvec(k);
564  for (i=0;i<k;i++)
565  {
566  if (res[syzIndex-1]->m[i]!=NULL) // hs
567  {
568  (*w)[i + rGetCurrSyzLimit(currRing)] = p_FDeg(res[syzIndex-1]->m[i],currRing);
569  if (pGetComp(res[syzIndex-1]->m[i])>0)
570  (*w)[i + rGetCurrSyzLimit(currRing)]
571  += (*w)[pGetComp(res[syzIndex-1]->m[i])-1];
572  (*((*weights)[syzIndex]))[i] = (*w)[i+rGetCurrSyzLimit(currRing)];
573  }
574  }
575  for (i=k;i<k+IDELEMS(res[syzIndex]);i++)
576  {
577  if (res[syzIndex]->m[i-k]!=NULL)
578  (*w)[i+rGetCurrSyzLimit(currRing)] = p_FDeg(res[syzIndex]->m[i-k],currRing)
579  +(*w)[pGetComp(res[syzIndex]->m[i-k])-1];
580  }
581  }
582  }
583 /*--- end of the main loop --------------------------------------*/
584 /*--- deleting the temporare data structures --------------------*/
585  if ((syzIndex!=0) && (res[syzIndex]!=NULL) && (idIs0(res[syzIndex])))
586  idDelete(&res[syzIndex]);
587  if (w !=NULL) delete w;
588 
589  Kstd1_deg=Kstd1_OldDeg;
590  if (!oldDegBound)
592 
593  for (i=1; i<=syzIndex; i++)
594  {
595  if ((res[i]!=NULL) && ! idIs0(res[i]))
596  {
598  }
599  }
600 /*--- going back to the original ring -------------------------*/
601  if (origR != syz_ring)
602  {
603  rChangeCurrRing(origR); // should not be needed now?
604  for (i=0; i<=syzIndex; i++)
605  {
606  res[i] = idrMoveR_NoSort(res[i], syz_ring, origR);
607  }
608  rDelete(syz_ring);
609  }
610  SI_RESTORE_OPT1(save1);
611  return res;
612 }
613 
614 syStrategy syResolution(ideal arg, int maxlength,intvec * w, BOOLEAN minim)
615 {
616 
617 #ifdef HAVE_PLURAL
618  const ideal idSaveCurrRingQuotient = currRing->qideal;
619  if( rIsSCA(currRing) )
620  {
622  {
623  currRing->qideal = SCAQuotient(currRing);
624  }
625  const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
626  const unsigned int m_iLastAltVar = scaLastAltVar(currRing);
627  arg = id_KillSquares(arg, m_iFirstAltVar, m_iLastAltVar, currRing, false); // kill suares in input!
628  }
629 #endif
630 
632 
633  if ((w!=NULL) && (!idTestHomModule(arg,currRing->qideal,w))) // is this right in SCA case???
634  {
635  WarnS("wrong weights given(2):");w->show();PrintLn();
636  idHomModule(arg,currRing->qideal,&w);
637  w->show();PrintLn();
638  w=NULL;
639  }
640  if (w!=NULL)
641  {
642  result->weights = (intvec**)omAlloc0Bin(char_ptr_bin);
643  (result->weights)[0] = ivCopy(w);
644  result->length = 1;
645  }
646  resolvente fr = syResolvente(arg,maxlength,&(result->length),&(result->weights),minim);
647  resolvente fr1;
648  if (minim)
649  {
650  result->minres = (resolvente)omAlloc0((result->length+1)*sizeof(ideal));
651  fr1 = result->minres;
652  }
653  else
654  {
655  result->fullres = (resolvente)omAlloc0((result->length+1)*sizeof(ideal));
656  fr1 = result->fullres;
657  }
658  for (int i=result->length-1;i>=0;i--)
659  {
660  if (fr[i]!=NULL)
661  fr1[i] = fr[i];
662  fr[i] = NULL;
663  }
664  omFreeSize((ADDRESS)fr,(result->length)*sizeof(ideal));
665 
666 #ifdef HAVE_PLURAL
667  if( rIsSCA(currRing) )
668  {
670  {
671  currRing->qideal = idSaveCurrRingQuotient;
672  }
673  id_Delete(&arg, currRing);
674  }
675 #endif
676 
677  return result;
678 }
679 
680 static poly sypCopyConstant(poly inp)
681 {
682  poly outp=NULL,q;
683 
684  while (inp!=NULL)
685  {
686  if (pLmIsConstantComp(inp))
687  {
688  if (outp==NULL)
689  {
690  q = outp = pHead(inp);
691  }
692  else
693  {
694  pNext(q) = pHead(inp);
695  pIter(q);
696  }
697  }
698  pIter(inp);
699  }
700  return outp;
701 }
702 int syDetect(ideal id,int index,BOOLEAN homog,int * degrees,int * tocancel)
703 {
704  int i, j, k, subFromRank=0;
705  ideal temp;
706 
707  if (idIs0(id)) return 0;
708  temp = idInit(IDELEMS(id),id->rank);
709  for (i=0;i<IDELEMS(id);i++)
710  {
711  temp->m[i] = sypCopyConstant(id->m[i]);
712  }
713  i = IDELEMS(id);
714  while ((i>0) && (temp->m[i-1]==NULL)) i--;
715  if (i==0)
716  {
717  idDelete(&temp);
718  return 0;
719  }
720  j = 0;
721  while ((j<i) && (temp->m[j]==NULL)) j++;
722  while (j<i)
723  {
724  if (homog)
725  {
726  if (index==0) k = p_FDeg(temp->m[j],currRing)+degrees[pGetComp(temp->m[j])];
727  else k = degrees[pGetComp(temp->m[j])];
728  if (k>=index) tocancel[k-index]++;
729  if ((k>=0) && (index==0)) subFromRank++;
730  }
731  else
732  {
733  tocancel[0]--;
734  }
735  syGaussForOne(temp,j,pGetComp(temp->m[j]),j+1,i);
736  j++;
737  while ((j<i) && (temp->m[j]==NULL)) j++;
738  }
739  idDelete(&temp);
740  return subFromRank;
741 }
742 
743 void syDetect(ideal id,int index,int rsmin, BOOLEAN homog,
744  intvec * degrees,intvec * tocancel)
745 {
746  int * deg=NULL;
747  int * tocan=(int*) omAlloc0(tocancel->length()*sizeof(int));
748  int i;
749 
750  if (homog)
751  {
752  deg = (int*) omAlloc0(degrees->length()*sizeof(int));
753  for (i=degrees->length();i>0;i--)
754  deg[i-1] = (*degrees)[i-1]-rsmin;
755  }
756  syDetect(id,index,homog,deg,tocan);
757  for (i=tocancel->length();i>0;i--)
758  (*tocancel)[i-1] = tocan[i-1];
759  if (homog)
760  omFreeSize((ADDRESS)deg,degrees->length()*sizeof(int));
761  omFreeSize((ADDRESS)tocan,tocancel->length()*sizeof(int));
762 }
763 
764 /*2
765 * computes the betti numbers from a given resolution
766 * of length 'length' (0..length-1), not necessairily minimal,
767 * (if weights are given, they are used)
768 * returns the int matrix of betti numbers
769 * and the regularity
770 */
771 intvec * syBetti(resolvente res,int length, int * regularity,
772  intvec* weights,BOOLEAN tomin,int * row_shift)
773 {
774 //#define BETTI_WITH_ZEROS
775  //tomin = FALSE;
776  int i,j=0,k=0,l,rows,cols,mr;
777  int *temp1,*temp2,*temp3;/*used to compute degrees*/
778  int *tocancel; /*(BOOLEAN)tocancel[i]=element is superfluous*/
779  int r0_len;
780 
781  /*------ compute size --------------*/
782  *regularity = -1;
783  cols = length;
784  while ((cols>0)
785  && ((res[cols-1]==NULL)
786  || (idIs0(res[cols-1]))))
787  {
788  cols--;
789  }
790  intvec * result;
791  if (idIs0(res[0]))
792  {
793  if (res[0]==NULL)
794  result = new intvec(1,1,1);
795  else
796  result = new intvec(1,1,res[0]->rank);
797  return result;
798  }
799  intvec *w=NULL;
800  if (weights!=NULL)
801  {
802  if (!idTestHomModule(res[0],currRing->qideal,weights))
803  {
804  WarnS("wrong weights given(3):");weights->show();PrintLn();
805  idHomModule(res[0],currRing->qideal,&w);
806  if (w!=NULL) { w->show();PrintLn();}
807  weights=NULL;
808  }
809  }
810 #if 0
811  if (idHomModule(res[0],currRing->qideal,&w)!=isHomog)
812  {
813  WarnS("betti-command: Input is not homogeneous!");
814  weights=NULL;
815  }
816 #endif
817  if (weights==NULL) weights=w;
818  else delete w;
819  r0_len=IDELEMS(res[0]);
820  while ((r0_len>0) && (res[0]->m[r0_len-1]==NULL)) r0_len--;
821  #ifdef SHOW_W
822  PrintS("weights:");if (weights!=NULL) weights->show(); else Print("NULL"); PrintLn();
823  #endif
824  int rkl=l = si_max(id_RankFreeModule(res[0],currRing),res[0]->rank);
825  i = 0;
826  while ((i<length) && (res[i]!=NULL))
827  {
828  if (IDELEMS(res[i])>l) l = IDELEMS(res[i]);
829  i++;
830  }
831  temp1 = (int*)omAlloc0((l+1)*sizeof(int));
832  temp2 = (int*)omAlloc((l+1)*sizeof(int));
833  rows = 1;
834  mr = 1;
835  cols++;
836  for (i=0;i<cols-1;i++)
837  {
838  if ((i==0) && (weights!=NULL)) p_SetModDeg(weights, currRing);
839  memset(temp2,0,(l+1)*sizeof(int));
840  for (j=0;j<IDELEMS(res[i]);j++)
841  {
842  if (res[i]->m[j]!=NULL)
843  {
844  if ((pGetComp(res[i]->m[j])>l)
845  // usual resolutions do not the following, but artifulal built may: (tr. #763)
846  //|| ((i>1) && (res[i-1]->m[pGetComp(res[i]->m[j])-1]==NULL))
847  )
848  {
849  WerrorS("input not a resolution");
850  omFreeSize((ADDRESS)temp1,(l+1)*sizeof(int));
851  omFreeSize((ADDRESS)temp2,(l+1)*sizeof(int));
852  return NULL;
853  }
854  temp2[j+1] = p_FDeg(res[i]->m[j],currRing)+temp1[pGetComp(res[i]->m[j])];
855  if (temp2[j+1]-i>rows) rows = temp2[j+1]-i;
856  if (temp2[j+1]-i<mr) mr = temp2[j+1]-i;
857  }
858  }
859  if ((i==0) && (weights!=NULL)) p_SetModDeg(NULL, currRing);
860  temp3 = temp1;
861  temp1 = temp2;
862  temp2 = temp3;
863  }
864  mr--;
865  if (weights!=NULL)
866  {
867  for(j=0;j<weights->length();j++)
868  {
869  if (rows <(*weights)[j]+1) rows=(-mr)+(*weights)[j]+1;
870  }
871  }
872  /*------ computation betti numbers --------------*/
873  rows -= mr;
874  result = new intvec(rows+1,cols,0);
875  if (weights!=NULL)
876  {
877  for(j=0;j<weights->length();j++)
878  {
879  IMATELEM((*result),(-mr)+(*weights)[j]+1,1) ++;
880  //Print("imat(%d,%d)++ -> %d\n",(-mr)+(*weights)[j]+1, 1, IMATELEM((*result),(-mr)+(*weights)[j]+1,1));
881  }
882  }
883  else
884  {
885  (*result)[(-mr)*cols] = /*idRankFreeModule(res[0])*/ rkl;
886  if ((!idIs0(res[0])) && ((*result)[(-mr)*cols]==0))
887  (*result)[(-mr)*cols] = 1;
888  }
889  tocancel = (int*)omAlloc0((rows+1)*sizeof(int));
890  memset(temp1,0,(l+1)*sizeof(int));
891  if (weights!=NULL)
892  {
893  memset(temp2,0,l*sizeof(int));
894  p_SetModDeg(weights, currRing);
895  }
896  else
897  memset(temp2,0,l*sizeof(int));
898  syDetect(res[0],0,TRUE,temp2,tocancel);
899  if (weights!=NULL) p_SetModDeg(NULL, currRing);
900  if (tomin)
901  {
902  //(*result)[(-mr)*cols] -= dummy;
903  for(j=0;j<=rows+mr;j++)
904  {
905  //Print("tocancel[%d]=%d imat(%d,%d)=%d\n",j,tocancel[j],(-mr)+j+1,1,IMATELEM((*result),(-mr)+j+1,1));
906  IMATELEM((*result),(-mr)+j+1,1) -= tocancel[j];
907  }
908  }
909  for (i=0;i<cols-1;i++)
910  {
911  if ((i==0) && (weights!=NULL)) p_SetModDeg(weights, currRing);
912  memset(temp2,0,l*sizeof(int));
913  for (j=0;j<IDELEMS(res[i]);j++)
914  {
915  if (res[i]->m[j]!=NULL)
916  {
917  temp2[j+1] = p_FDeg(res[i]->m[j],currRing)+temp1[pGetComp(res[i]->m[j])];
918  //(*result)[i+1+(temp2[j+1]-i-1)*cols]++;
919  //if (temp2[j+1]>i) IMATELEM((*result),temp2[j+1]-i-mr,i+2)++;
920  IMATELEM((*result),temp2[j+1]-i-mr,i+2)++;
921  }
922  else if (i==0)
923  {
924  if (j<r0_len) IMATELEM((*result),-mr,2)++;
925  }
926  }
927  /*------ computation betti numbers, if res not minimal --------------*/
928  if (tomin)
929  {
930  for (j=mr;j<rows+mr;j++)
931  {
932  //(*result)[i+1+j*cols] -= tocancel[j+1];
933  IMATELEM((*result),j+1-mr,i+2) -= tocancel[j+1];
934  }
935  if ((i<length-1) && (res[i+1]!=NULL))
936  {
937  memset(tocancel,0,(rows+1)*sizeof(int));
938  syDetect(res[i+1],i+1,TRUE,temp2,tocancel);
939  for (j=0;j<rows;j++)
940  {
941  //(*result)[i+1+j*cols] -= tocancel[j];
942  IMATELEM((*result),j+1,i+2) -= tocancel[j];
943  }
944  }
945  }
946  temp3 = temp1;
947  temp1 = temp2;
948  temp2 = temp3;
949  for (j=0;j<=rows;j++)
950  {
951  // if (((*result)[i+1+j*cols]!=0) && (j>*regularity)) *regularity = j;
952  if ((IMATELEM((*result),j+1,i+2)!=0) && (j>*regularity)) *regularity = j;
953  }
954  if ((i==0) && (weights!=NULL)) p_SetModDeg(NULL, currRing);
955  }
956  // Print("nach minim:\n"); result->show(); PrintLn();
957  /*------ clean up --------------*/
958  omFreeSize((ADDRESS)tocancel,(rows+1)*sizeof(int));
959  omFreeSize((ADDRESS)temp1,(l+1)*sizeof(int));
960  omFreeSize((ADDRESS)temp2,(l+1)*sizeof(int));
961  if ((tomin) && (mr<0)) // deletes the first (zero) line
962  {
963  for (j=1;j<=rows+mr+1;j++)
964  {
965  for (k=1;k<=cols;k++)
966  {
967  IMATELEM((*result),j,k) = IMATELEM((*result),j-mr,k);
968  }
969  }
970  for (j=rows+mr+1;j<=rows+1;j++)
971  {
972  for (k=1;k<=cols;k++)
973  {
974  IMATELEM((*result),j,k) = 0;
975  }
976  }
977  }
978  j = 0;
979  k = 0;
980  for (i=1;i<=result->rows();i++)
981  {
982  for(l=1;l<=result->cols();l++)
983  if (IMATELEM((*result),i,l) != 0)
984  {
985  j = si_max(j, i-1);
986  k = si_max(k, l-1);
987  }
988  }
989  intvec * exactresult=new intvec(j+1,k+1,0);
990  for (i=0;i<exactresult->rows();i++)
991  {
992  for (j=0;j<exactresult->cols();j++)
993  {
994  IMATELEM(*exactresult,i+1,j+1) = IMATELEM(*result,i+1,j+1);
995  }
996  }
997  if (row_shift!=NULL) *row_shift = mr;
998  delete result;
999  return exactresult;
1000 }
1001 
1002 /*2
1003 * minbare via syzygies
1004 */
1005 ideal syMinBase(ideal arg)
1006 {
1007  intvec ** weights=NULL;
1008  int leng;
1009  if (idIs0(arg)) return idInit(1,arg->rank);
1010  resolvente res=syResolvente(arg,1,&leng,&weights,TRUE);
1011  ideal result=res[0];
1012  omFreeSize((ADDRESS)res,leng*sizeof(ideal));
1013  if (weights!=NULL)
1014  {
1015  if (*weights!=NULL)
1016  {
1017  delete (*weights);
1018  *weights=NULL;
1019  }
1020  if ((leng>=1) && (*(weights+1)!=NULL))
1021  {
1022  delete *(weights+1);
1023  *(weights+1)=NULL;
1024  }
1025  }
1027  return result;
1028 }
1029 
1030 #if 0 /* currently used: syBetti */
1031 /*2
1032 * computes Betti-numbers from a resolvente of
1033 * (non-)homogeneous objects
1034 * the numbers of entrees !=NULL in res and weights must be equal
1035 * and < length
1036 */
1037 intvec * syNewBetti(resolvente res, intvec ** weights, int length)
1038 {
1039  intvec * result,*tocancel;
1040  int i,j,k,rsmin=0,rsmax=0,rs=0;
1041  BOOLEAN homog=TRUE;
1042 
1043  if (weights!=NULL) //---homogeneous Betti numbers
1044  {
1045 /*--------------computes size of the field----------------------*/
1046  for (i=1;i<length;i++)
1047  {
1048  if (weights[i] != NULL)
1049  {
1050  for (j=1;j<(weights[i])->length();j++)
1051  {
1052  if ((*(weights[i]))[j]-i<rsmin) rsmin = (*(weights[i]))[j]-i;
1053  if ((*(weights[i]))[j]-i>rsmax) rsmax = (*(weights[i]))[j]-i;
1054  }
1055  }
1056  }
1057  i = 0;
1058  while (weights[i] != NULL) i++;
1059  i--;
1060  for (j=0;j<IDELEMS(res[i]);j++)
1061  {
1062  if (res[i]->m[j]!=NULL)
1063  {
1064  k = p_FDeg(res[i]->m[j],currRing)+(*(weights[i]))[pGetComp(res[i]->m[j])]-i-1;
1065  if (k>rsmax) rsmax = k;
1066  if (k<rsmin) rsmin = k;
1067  }
1068  }
1069  for (j=1;j<(weights[0])->length();j++)
1070  {
1071  if ((*weights[0])[j]>rsmax) rsmax = (*weights[0])[j];
1072  if ((*weights[0])[j]<rsmin) rsmin = (*weights[0])[j];
1073  }
1074 //Print("rsmax = %d\n",rsmax);
1075 //Print("rsmin = %d\n",rsmin);
1076  rs = rsmax-rsmin+1;
1077  result = new intvec(rs,i+2,0);
1078  tocancel = new intvec(rs);
1079 /*-----------enter the Betti numbers-------------------------------*/
1080  if (/*idRankFreeModule(res[0])*/ res[0]->rank==0)
1081  {
1082  IMATELEM(*result,1-rsmin,1)=1;
1083  }
1084  else
1085  {
1086  for (i=1;i<(weights[0])->length();i++)
1087  IMATELEM(*result,(*weights[0])[i]+1-rsmin,1)++;
1088  }
1089  i = 1;
1090  while (weights[i]!=NULL)
1091  {
1092  for (j=1;j<(weights[i])->length();j++)
1093  {
1094  IMATELEM(*result,(*(weights[i]))[j]-i+1-rsmin,i+1)++;
1095  }
1096  i++;
1097  }
1098  i--;
1099  for (j=0;j<IDELEMS(res[i]);j++)
1100  {
1101  if (res[i]->m[j]!=NULL)
1102  {
1103  k = p_FDeg(res[i]->m[j],currRing)+(*(weights[i]))[pGetComp(res[i]->m[j])]-i;
1104  IMATELEM(*result,k-rsmin,i+2)++;
1105  }
1106  }
1107  }
1108  else //-----the non-homgeneous case
1109  {
1110  homog = FALSE;
1111  tocancel = new intvec(1);
1112  k = length;
1113  while ((k>0) && (idIs0(res[k-1]))) k--;
1114  result = new intvec(1,k+1,0);
1115  (*result)[0] = res[0]->rank;
1116  for (i=0;i<length;i++)
1117  {
1118  if (res[i]!=NULL)
1119  {
1120  for (j=0;j<IDELEMS(res[i]);j++)
1121  {
1122  if (res[i]->m[j]!=NULL) (*result)[i+1]++;
1123  }
1124  }
1125  }
1126  }
1127 /*--------computes the Betti numbers for the minimized reolvente----*/
1128 
1129  i = 1;
1130  while ((res[i]!=NULL) && (weights[i]!=NULL))
1131  {
1132  syDetect(res[i],i,rsmin,homog,weights[i],tocancel);
1133  if (homog)
1134  {
1135  for (j=0;j<rs-1;j++)
1136  {
1137  IMATELEM((*result),j+1,i+1) -= (*tocancel)[j];
1138  IMATELEM((*result),j+1,i+2) -= (*tocancel)[j+1];
1139  }
1140  IMATELEM((*result),rs,i+1) -= (*tocancel)[rs-1];
1141  }
1142  else
1143  {
1144  (*result)[i+1] -= (*tocancel)[0];
1145  (*result)[i+2] -= (*tocancel)[0];
1146  }
1147  i++;
1148  }
1149 
1150 /*--------print Betti numbers for control---------------------------*/
1151  for(i=rsmin;i<=rsmax;i++)
1152  {
1153  Print("%2d:",i);
1154  for(j=1;j<=result->cols();j++)
1155  {
1156  Print(" %5d",IMATELEM(*result,i-rsmin+1,j));
1157  }
1158  PrintLn();
1159  }
1160  return result;
1161 }
1162 #endif
1163 
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
int BOOLEAN
Definition: auxiliary.h:85
#define TRUE
Definition: auxiliary.h:98
#define FALSE
Definition: auxiliary.h:94
void * ADDRESS
Definition: auxiliary.h:133
CF_NO_INLINE CanonicalForm mod(const CanonicalForm &, const CanonicalForm &)
Definition: cf_inline.cc:564
int * degrees(const CanonicalForm &f, int *degs=0)
int * degrees ( const CanonicalForm & f, int * degs )
Definition: cf_ops.cc:493
int l
Definition: cfEzgcd.cc:93
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
int k
Definition: cfEzgcd.cc:92
int p
Definition: cfModGcd.cc:4019
Definition: intvec.h:21
void show(int mat=0, int spaces=0) const
Definition: intvec.cc:149
int length() const
Definition: intvec.h:92
int cols() const
Definition: intvec.h:93
int rows() const
Definition: intvec.h:94
#define Print
Definition: emacs.cc:80
#define WarnS
Definition: emacs.cc:78
return result
Definition: facAbsBiFact.cc:76
CanonicalForm res
Definition: facAbsFact.cc:64
const CanonicalForm & w
Definition: facAbsFact.cc:55
int j
Definition: facHensel.cc:105
void WerrorS(const char *s)
Definition: feFopen.cc:24
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition: ideals.cc:730
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
Definition: ideals.cc:2100
ideal idMinEmbedding(ideal arg, BOOLEAN inPlace, intvec **w)
Definition: ideals.cc:2565
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96
ideal idCopy(ideal A)
Definition: ideals.h:60
ideal * resolvente
Definition: ideals.h:18
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:263
#define IMATELEM(M, I, J)
Definition: intvec.h:83
intvec * ivCopy(const intvec *o)
Definition: intvec.h:133
static Poly * h
Definition: janet.cc:972
ideal kInterRedOld(ideal F, ideal Q)
Definition: kstd1.cc:3028
int Kstd1_deg
Definition: kstd1.h:47
static bool rIsSCA(const ring r)
Definition: nc.h:190
bool ncExtensions(int iMask)
Definition: old.gring.cc:94
const int TESTSYZSCAMASK
Definition: nc.h:342
ideal id_KillSquares(const ideal id, const short iFirstAltVar, const short iLastAltVar, const ring r, const bool bSkipZeroes)
Definition: sca.cc:1520
#define assume(x)
Definition: mod2.h:390
#define pIter(p)
Definition: monomials.h:38
#define pNext(p)
Definition: monomials.h:37
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define NULL
Definition: omList.c:10
unsigned si_opt_1
Definition: options.c:5
#define SI_SAVE_OPT1(A)
Definition: options.h:22
#define SI_RESTORE_OPT1(A)
Definition: options.h:25
#define Sy_bit(x)
Definition: options.h:32
#define TEST_OPT_DEGBOUND
Definition: options.h:112
#define TEST_OPT_NOTREGULARITY
Definition: options.h:118
#define TEST_OPT_PROT
Definition: options.h:102
#define OPT_DEGBOUND
Definition: options.h:89
#define TEST_OPT_NO_SYZ_MINIM
Definition: options.h:122
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2782
void p_SetModDeg(intvec *w, ring r)
Definition: p_polys.cc:3624
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:381
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
void rChangeCurrRing(ring r)
Definition: polys.cc:15
Compatiblity layer for legacy polynomial operations (over currRing)
static long pTotaldegree(poly p)
Definition: polys.h:276
#define pDelete(p_ptr)
Definition: polys.h:181
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
#define pLmIsConstantComp(p)
like above, except that p must be != NULL
Definition: polys.h:237
#define pDeleteComp(p, k)
Definition: polys.h:355
#define pGetComp(p)
Component.
Definition: polys.h:37
#define pSub(a, b)
Definition: polys.h:281
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
#define pMult(p, q)
Definition: polys.h:202
#define pVectorHasUnitB(p, k)
Definition: polys.h:326
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 ...
Definition: polys.h:333
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180
#define pVectorHasUnit(p, k, l)
Definition: polys.h:327
ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
Definition: prCopy.cc:261
ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
Definition: prCopy.cc:205
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310
ring rAssure_SyzComp(const ring r, BOOLEAN complete)
Definition: ring.cc:4367
int rGetMaxSyzComp(int i, const ring r)
return the max-comonent wchich has syzIndex i Assume: i<= syzIndex_limit
Definition: ring.cc:5063
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:437
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:4991
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:475
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:398
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:713
BOOLEAN rHasGlobalOrdering(const ring r)
Definition: ring.h:750
static BOOLEAN rField_has_simple_inverse(const ring r)
Definition: ring.h:539
ideal SCAQuotient(const ring r)
Definition: sca.h:10
static short scaLastAltVar(ring r)
Definition: sca.h:25
static short scaFirstAltVar(ring r)
Definition: sca.h:18
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:37
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
ideal id_Jet(const ideal i, int d, const ring R)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
void id_Shift(ideal M, int s, const ring r)
#define IDELEMS(i)
Definition: simpleideals.h:24
omBin char_ptr_bin
Definition: ring.cc:45
tHomog
Definition: structs.h:38
@ isHomog
Definition: structs.h:40
@ isNotHomog
Definition: structs.h:39
#define BITSET
Definition: structs.h:18
int syDetect(ideal id, int index, BOOLEAN homog, int *degrees, int *tocancel)
Definition: syz.cc:702
resolvente syResolvente(ideal arg, int maxlength, int *length, intvec ***weights, BOOLEAN minim)
Definition: syz.cc:390
syStrategy syResolution(ideal arg, int maxlength, intvec *w, BOOLEAN minim)
Definition: syz.cc:614
static poly sypCopyConstant(poly inp)
Definition: syz.cc:680
static void syMinStep1(resolvente res, int length)
Definition: syz.cc:290
static void syMinStep(ideal mod, ideal &syz, BOOLEAN final=FALSE, ideal up=NULL, tHomog h=isNotHomog)
Definition: syz.cc:83
ideal syMinBase(ideal arg)
Definition: syz.cc:1005
intvec * syBetti(resolvente res, int length, int *regularity, intvec *weights, BOOLEAN tomin, int *row_shift)
Definition: syz.cc:771
void syGaussForOne(ideal syz, int elnum, int ModComp, int from, int till)
Definition: syz.cc:219
static void syDeleteAbove1(ideal up, int k)
Definition: syz.cc:246
static intvec * syPrepareModComp(ideal arg, intvec **w)
Definition: syz.cc:26
static void syDeleteAbove(ideal up, int k)
Definition: syz.cc:67
void syMinimizeResolvente(resolvente res, int length, int first)
Definition: syz.cc:356
void syKillEmptyEntres(resolvente res, int length)
Definition: syz1.cc:2201
ssyStrategy * syStrategy
Definition: syz.h:35