Changeset 3cc89c in git

Timestamp:

Jun 1, 2015, 12:19:52 PM (8 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

dd52bad670674af5262a9ad0f203b628a7a36a0e

Parents:

f7f34606f7ff04570296a86535c421167f902351

Message:

prod-crit for IDLIFT case

also: cleanup setting of enterOnePair
      removed (unused) strat->interred_flag

Location:

kernel/GBEngine

Files:

• kstd1.cc (modified) (2 diffs)
• kutil.cc (modified) (9 diffs)
• kutil.h (modified) (2 diffs)

kernel/GBEngine/kstd1.cc

@@ -1643 +1643 @@
       {
         WerrorS("expoent overflow - wrong ordering");
-        return(idInit(1,1));
+        return(idInit(1,1));
       }
       // set ecart -- might have changed because of tail reductions
@@ -2094 +2094 @@
     strat->LazyPass=2;
   strat->LazyDegree = 1;
-  strat->enterOnePair=enterOnePairNormal;
-  strat->chainCrit=chainCritNormal;
   strat->ak = id_RankFreeModule(F,currRing);
   strat->kModW=kModW=NULL;

kernel/GBEngine/kutil.cc

@@ -1172 +1172 @@
   LObject  Lp;
 
-  if (strat->interred_flag) return;
 #ifdef KDEBUG
   Lp.ecart=0; Lp.length=0;
@@ -1492 +1491 @@
 {
   assume(i<=strat->sl);
-  if (strat->interred_flag) return;
 
   int      l,j,compare;
@@ -1777 +1775 @@
 }
 
+/// p_HasNotCF for the IDLIFT case: ignore component
+static BOOLEAN p_HasNotCF_Lift(poly p1, poly p2, const ring r)
+{
+  int i = rVar(r);
+  loop
+  {
+    if ((p_GetExp(p1, i, r) > 0) && (p_GetExp(p2, i, r) > 0))
+      return FALSE;
+    i--;
+    if (i == 0)
+      return TRUE;
+  }
+}
+
+/*2
+* put the pair (s[i],p)  into the set B, ecart=ecart(p) for idLift(I,T)
+*/
+
+void enterOnePairLift (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR = -1)
+{
+  assume(ALLOW_PROD_CRIT(strat));
+  assume(!rIsPluralRing(currRing));
+  assume(strat->syzComp==1);
+  assume(i<=strat->sl);
+
+  int      l,j,compare;
+  LObject  Lp;
+  Lp.i_r = -1;
+
+#ifdef KDEBUG
+  Lp.ecart=0; Lp.length=0;
+#endif
+  /*- computes the lcm(s[i],p) -*/
+  Lp.lcm = pInit();
+
+  pLcm(p,strat->S[i],Lp.lcm);
+  pSetm(Lp.lcm);
+
+  if (strat->sugarCrit)
+  {
+    if((!((strat->ecartS[i]>0)&&(ecart>0)))
+    && p_HasNotCF_Lift(p,strat->S[i],currRing))
+    {
+    /*
+    *the product criterion has applied for (s,p),
+    *i.e. lcm(s,p)=product of the leading terms of s and p.
+    *Suppose (s,r) is in L and the leading term
+    *of p divides lcm(s,r)
+    *(==> the leading term of p divides the leading term of r)
+    *but the leading term of s does not divide the leading term of r
+    *(notice that tis condition is automatically satisfied if r is still
+    *in S), then (s,r) can be cancelled.
+    *This should be done here because the
+    *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
+    *
+    *Moreover, skipping (s,r) holds also for the noncommutative case.
+    */
+      strat->cp++;
+      pLmFree(Lp.lcm);
+      Lp.lcm=NULL;
+      return;
+    }
+    else
+      Lp.ecart = si_max(ecart,strat->ecartS[i]);
+    if (strat->fromT && (strat->ecartS[i]>ecart))
+    {
+      pLmFree(Lp.lcm);
+      Lp.lcm=NULL;
+      return;
+      /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
+    }
+    /*
+    *the set B collects the pairs of type (S[j],p)
+    *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
+    *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
+    *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
+    */
+    {
+      j = strat->Bl;
+      loop
+      {
+        if (j < 0)  break;
+        compare=pDivComp(strat->B[j].lcm,Lp.lcm);
+        if ((compare==1)
+        &&(sugarDivisibleBy(strat->B[j].ecart,Lp.ecart)))
+        {
+          strat->c3++;
+          if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
+          {
+            pLmFree(Lp.lcm);
+            return;
+          }
+          break;
+        }
+        else
+        if ((compare ==-1)
+        && sugarDivisibleBy(Lp.ecart,strat->B[j].ecart))
+        {
+          deleteInL(strat->B,&strat->Bl,j,strat);
+          strat->c3++;
+        }
+        j--;
+      }
+    }
+  }
+  else /*sugarcrit*/
+  {
+    if(/*(strat->ak==0) && productCrit(p,strat->S[i])*/
+    p_HasNotCF_Lift(p,strat->S[i],currRing))
+    {
+    /*
+    *the product criterion has applied for (s,p),
+    *i.e. lcm(s,p)=product of the leading terms of s and p.
+    *Suppose (s,r) is in L and the leading term
+    *of p devides lcm(s,r)
+    *(==> the leading term of p devides the leading term of r)
+    *but the leading term of s does not devide the leading term of r
+    *(notice that tis condition is automatically satisfied if r is still
+    *in S), then (s,r) can be canceled.
+    *This should be done here because the
+    *case lcm(s,r)=lcm(s,p) is not covered by chainCrit.
+    */
+        strat->cp++;
+        pLmFree(Lp.lcm);
+        Lp.lcm=NULL;
+        return;
+    }
+    if (strat->fromT && (strat->ecartS[i]>ecart))
+    {
+      pLmFree(Lp.lcm);
+      Lp.lcm=NULL;
+      return;
+      /*the pair is (s[i],t[.]), discard it if the ecart is too big*/
+    }
+    /*
+    *the set B collects the pairs of type (S[j],p)
+    *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
+    *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
+    *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
+    */
+    for(j = strat->Bl;j>=0;j--)
+    {
+      compare=pDivComp(strat->B[j].lcm,Lp.lcm);
+      if (compare==1)
+      {
+        strat->c3++;
+        if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
+        {
+          pLmFree(Lp.lcm);
+          return;
+        }
+        break;
+      }
+      else
+      if (compare ==-1)
+      {
+        deleteInL(strat->B,&strat->Bl,j,strat);
+        strat->c3++;
+      }
+    }
+  }
+  /*
+  *the pair (S[i],p) enters B if the spoly != 0
+  */
+  /*-  compute the short s-polynomial -*/
+  if (strat->fromT && !TEST_OPT_INTSTRATEGY)
+    pNorm(p);
+
+  if ((strat->S[i]==NULL) || (p==NULL))
+    return;
+
+  if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
+    Lp.p=NULL;
+  else
+  {
+      assume(!rIsPluralRing(currRing));
+      Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
+  }
+  if (Lp.p == NULL)
+  {
+    /*- the case that the s-poly is 0 -*/
+    if (strat->pairtest==NULL) initPairtest(strat);
+    strat->pairtest[i] = TRUE;/*- hint for spoly(S^[i],p)=0 -*/
+    strat->pairtest[strat->sl+1] = TRUE;
+    /*hint for spoly(S[i],p) == 0 for some i,0 <= i <= sl*/
+    /*
+    *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
+    *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
+    *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
+    *term of p devides the lcm(s,r)
+    *(this canceling should be done here because
+    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
+    *the first case is handeled in chainCrit
+    */
+    if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
+  }
+  else
+  {
+    /*- the pair (S[i],p) enters B -*/
+    Lp.p1 = strat->S[i];
+    Lp.p2 = p;
+
+    pNext(Lp.p) = strat->tail; // !!!
+
+    if (atR >= 0)
+    {
+      Lp.i_r1 = strat->S_2_R[i];
+      Lp.i_r2 = atR;
+    }
+    else
+    {
+      Lp.i_r1 = -1;
+      Lp.i_r2 = -1;
+    }
+    strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
+
+    if (TEST_OPT_INTSTRATEGY)
+    {
+        nDelete(&(Lp.p->coef));
+    }
+
+    l = strat->posInL(strat->B,strat->Bl,&Lp,strat);
+    enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
+  }
+}
+
 /*2
 * put the pair (s[i],p)  into the set B, ecart=ecart(p)
@@ -1789 +2013 @@
 {
   assume(i<=strat->sl);
-  if (strat->interred_flag) return;
 
   int      l;
@@ -3077 +3300 @@
   LObject  Lp;
 
-  if (strat->interred_flag) return;
 #ifdef KDEBUG
   Lp.ecart=0; Lp.length=0;
@@ -7356 +7578 @@
   }
 #endif
+  if (TEST_OPT_IDLIFT  /* i.e. also strat->syzComp==1 */
+  && (!rIsPluralRing(currRing))
+    strat->enterOnePair=enterOnePairLift;
+
 
   strat->sugarCrit =        TEST_OPT_SUGARCRIT;
@@ -9181 +9407 @@
 
   assume(i<=strat->sl); // from OnePair
-  if (strat->interred_flag) return; // ?
 
   /* these vars hold for all shifts of s[i] */
@@ -9260 +9485 @@
 
   poly q;
-
-  if (strat->interred_flag) return; // ?
 
   /* these vars hold for all shifts of s[i] */
@@ -9320 +9543 @@
 
   /* need additionally: int up_to_degree, poly V0 with the variables in (0)  or just the number lV = the length of the first block */
-
-  if (strat->interred_flag) return;
 
   int      l,j,compare;

kernel/GBEngine/kutil.h

@@ -377 +377 @@
   BOOLEAN posInLOldFlag;
   BOOLEAN use_buckets;
-  BOOLEAN interred_flag;
   // if set, pLDeg(p, l) == (pFDeg(pLast(p), pLength)
   BOOLEAN LDegLast;
@@ -541 +540 @@
 void kFreeStrat(kStrategy strat);
 void enterOnePairNormal (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);
+void enterOnePairLift (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR);
 void enterOnePairSig (int i,poly p,poly pSig,int ecart, int isFromQ,kStrategy strat, int atR);
 void chainCritNormal (poly p,int ecart,kStrategy strat);