Changeset c8523f in git for kernel/GBEngine

Timestamp:

Oct 7, 2015, 4:51:45 PM (9 years ago)

Author:

Adi Popescu <adi_popescum@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'd08f5f0bb3329b8ca19f23b74cb1473686415c3a')

Children:

212806f6073de03851c64acb881326ea4667bad2

Parents:

03305393d877240ff162abbfb9e1b9c1f14214e85d9204728b9fa909f073b21e83c172b0b49dc2e2

Message:

Merge branch 'Anne' into STDChanges

Location:

kernel/GBEngine

Files:

• kspoly.cc (modified) (2 diffs)
• kstd1.cc (modified) (6 diffs)
• kstd2.cc (modified) (1 diff)
• kutil.cc (modified) (29 diffs)
• kutil.h (modified) (2 diffs)

kernel/GBEngine/kspoly.cc

@@ -49 +49 @@
     Print("Red %d:", red_count); PR->wrp(); Print(" with:");
     PW->wrp();
+    //printf("\necart(PR)-ecart(PW): %i\n",PR->ecart-PW->ecart);
+    //pWrite(PR->p);
   }
 #endif
@@ -159 +161 @@
   {
     Print(" to: "); PR->wrp(); Print("\n");
+    //printf("\nt^%i ", PR->ecart);pWrite(pHead(PR->p)); 
   }
 #endif

kernel/GBEngine/kstd1.cc

@@ -402 +402 @@
       PrintS("\n    No poly in T divides h.\n");
     }
+    //getchar();
 #endif
     if (j < 0)
@@ -734 +735 @@
   loop
   {
+    #if ADIDEBUG_NF
+    for(int ii=0;ii<=strat->tl;ii++)
+    {
+      printf("\nT[%i]:\nt^%i ",ii,strat->T[ii].ecart);
+      pWrite(strat->T[ii].p);
+    }
+    //getchar();
+    #endif
     if (j > strat->tl)
     {
@@ -813 +822 @@
         if (H.p == NULL)
           return NULL;
+        #if 0
+        //kÃŒrzeste=1, kleinste ecart = 0
+        int dummy=0;
+        int z=-1;
+        for(int ii=0; ii<=strat->tl;ii++)
+        {
+          if(pLmIsConstant(strat->T[ii].p))
+          {
+            printf("\nFound one:\n");pWrite(strat->T[ii].p);
+            if(dummy==0 && strat->T[ii].ecart < strat->T[z].ecart)
+            {
+              z = ii;
+            }
+            if(dummy == 1 && strat->T[ii].length < strat->T[z].length)
+            {
+              z = ii;
+            }
+          }
+        }
+        printf("\n!!!!!!!!!!!!!!!!!   z = %i\n",z);
+        if(z!=-1)
+        {
+          enterOneStrongPoly(z,H.p,H.ecart,0,strat,-1 , TRUE);
+        }
+        #endif
       }
       else
@@ -825 +859 @@
       #if ADIDEBUG_NF
       printf("\nAfter the small reduction it looks like this:\n");pWrite(H.p);
-      getchar();
+      //getchar();
       #endif
       /*- try to reduce the s-polynomial -*/
@@ -1667 +1701 @@
       printf("\nBefore Ll = %i\n", strat->Ll);
       #endif
-      red_result = strat->red(&strat->P,strat);
+      #ifdef HAVE_RINGS
+      if(rField_is_Ring(strat->tailRing) && rHasLocalOrMixedOrdering(currRing))
+      {
+        int inittl = strat->tl;
+        red_result = strat->red(&strat->P,strat);
+        strat->tl = inittl;
+      }
+      else
+      #endif
+        red_result = strat->red(&strat->P,strat);
       #if ADIDEBUG
       printf("\nThis is P nach red:\n");p_Write(strat->P.p,strat->tailRing);p_Write(strat->P.p1,strat->tailRing);p_Write(strat->P.p2,strat->tailRing);
@@ -1699 +1742 @@
 
       // put in T
-      enterT(strat->P,strat);
+      #ifdef HAVE_RINGS
+      if(rField_is_Ring(strat->tailRing) && rHasLocalOrMixedOrdering(currRing))
+      {
+        int inittl = strat->tl;
+        enterT(strat->P,strat);
+        strat->tl = inittl+1;
+      }
+      else
+        enterT(strat->P,strat);
+      #endif
       // build new pairs
 #ifdef HAVE_RINGS

kernel/GBEngine/kstd2.cc

@@ -1558 +1558 @@
     }
     #endif
-    getchar();
+    //getchar();
     #endif
     #ifdef KDEBUG

kernel/GBEngine/kutil.cc

@@ -1168 +1168 @@
 void enterOnePairRing (int i,poly p,int ecart, int isFromQ,kStrategy strat, int atR = -1)
 {
-  number s, t;
+  #if 0
+  assume(i<=strat->sl);
+    int      l,j,compare,compareCoeff;
+    LObject  Lp;
+    if (strat->interred_flag) return;
+  #ifdef KDEBUG
+    Lp.ecart=0; Lp.length=0;
+  #endif
+    /*- computes the lcm(s[i],p) -*/
+    Lp.lcm = pInit();
+    pSetCoeff0(Lp.lcm, n_Lcm(pGetCoeff(p), pGetCoeff(strat->S[i]), currRing->cf));
+  
+    // Lp.lcm == 0
+    if (nIsZero(pGetCoeff(Lp.lcm)))
+    {
+  #ifdef KDEBUG
+        if (TEST_OPT_DEBUG)
+        {
+          PrintS("--- Lp.lcm == 0\n");
+          PrintS("p:");
+          wrp(p);
+          Print("  strat->S[%d]:", i);
+          wrp(strat->S[i]);
+          PrintLn();
+        }
+  #endif
+        strat->cp++;
+        pLmDelete(Lp.lcm);
+        return;
+    }
+    // basic product criterion
+    pLcm(p,strat->S[i],Lp.lcm);
+  
+    pSetm(Lp.lcm);
+    assume(!strat->sugarCrit);
+    if (pHasNotCF(p,strat->S[i]) && n_IsUnit(pGetCoeff(p),currRing->cf)
+        && n_IsUnit(pGetCoeff(strat->S[i]),currRing->cf))
+    {
+  #ifdef KDEBUG
+        if (TEST_OPT_DEBUG)
+        {
+          PrintS("--- product criterion func enterOnePairRing type 1\n");
+          PrintS("p:");
+          wrp(p);
+          Print("  strat->S[%d]:", i);
+          wrp(strat->S[i]);
+          PrintLn();
+        }
+  #endif
+        strat->cp++;
+        pLmDelete(Lp.lcm);
+        return;
+    }
+    assume(!strat->fromT);
+    /*
+    *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=pDivCompRing(strat->B[j].lcm,Lp.lcm);
+      compareCoeff = n_DivComp(pGetCoeff(strat->B[j].lcm), pGetCoeff(Lp.lcm), currRing->cf);
+      if ((compareCoeff == pDivComp_EQUAL) || (compare == compareCoeff))
+      {
+        if (compare == 1)
+        {
+          strat->c3++;
+  #ifdef KDEBUG
+          if (TEST_OPT_DEBUG)
+          {
+            PrintS("--- chain criterion type 1\n");
+            PrintS("strat->B[j]:");
+            wrp(strat->B[j].lcm);
+            PrintS("  Lp.lcm:");
+            wrp(Lp.lcm);
+            PrintLn();
+          }
+  #endif
+          if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
+          {
+            pLmDelete(Lp.lcm);
+            return;
+          }
+          break;
+        }
+        else
+        if (compare == -1)
+        {
+  #ifdef KDEBUG
+          if (TEST_OPT_DEBUG)
+          {
+            PrintS("--- chain criterion type 2\n");
+            Print("strat->B[%d].lcm:",j);
+            wrp(strat->B[j].lcm);
+            PrintS("  Lp.lcm:");
+            wrp(Lp.lcm);
+            PrintLn();
+          }
+  #endif
+          deleteInL(strat->B,&strat->Bl,j,strat);
+          strat->c3++;
+        }
+      }
+      if ((compare == pDivComp_EQUAL) && (compareCoeff != 2))
+      {
+        if (compareCoeff == pDivComp_LESS)
+        {
+  #ifdef KDEBUG
+          if (TEST_OPT_DEBUG)
+          {
+            PrintS("--- chain criterion type 3\n");
+            Print("strat->B[%d].lcm:", j);
+            wrp(strat->B[j].lcm);
+            PrintS("  Lp.lcm:");
+            wrp(Lp.lcm);
+            PrintLn();
+          }
+  #endif
+          strat->c3++;
+          if ((strat->fromQ==NULL) || (isFromQ==0) || (strat->fromQ[i]==0))
+          {
+            pLmDelete(Lp.lcm);
+            return;
+          }
+          break;
+        }
+        else
+        // Add hint for same LM and LC (later) (TODO Oliver)
+        // if (compareCoeff == pDivComp_GREATER)
+        {
+  #ifdef KDEBUG
+          if (TEST_OPT_DEBUG)
+          {
+            PrintS("--- chain criterion type 4\n");
+            Print("strat->B[%d].lcm:", j);
+            wrp(strat->B[j].lcm);
+            PrintS("  Lp.lcm:");
+            wrp(Lp.lcm);
+            PrintLn();
+          }
+  #endif
+          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->S[i]==NULL) || (p==NULL))
+    {
+  #ifdef KDEBUG
+      if (TEST_OPT_DEBUG)
+      {
+        PrintS("--- spoly = NULL\n");
+      }
+  #endif
+      pLmDelete(Lp.lcm);
+      return;
+    }
+    if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
+    {
+      // Is from a previous computed GB, therefore we know that spoly will
+      // reduce to zero. Oliver.
+      WarnS("Could we come here? 8738947389");
+      Lp.p=NULL;
+    }
+    else
+    {
+      Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
+    }
+    if (Lp.p == NULL)
+    {
+  #ifdef KDEBUG
+      if (TEST_OPT_DEBUG)
+      {
+        PrintS("--- spoly = NULL\n");
+      }
+  #endif
+      /*- 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
+      */
+      pLmDelete(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_r2 = atR;
+        Lp.i_r1 = strat->S_2_R[i];
+      }
+      strat->initEcartPair(&Lp,strat->S[i],p,strat->ecartS[i],ecart);
+      l = strat->posInL(strat->L,strat->Ll,&Lp,strat);
+      enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,l);
+    }
+  #else
   assume(i<=strat->sl);
   assume(atR >= 0);
@@ -1312 +1527 @@
   }
   #endif
+  number s, t;
   poly m1, m2, gcd;
   #if ADIDEBUG
@@ -1333 +1549 @@
     if(pm1 == NULL)
     {
-      pDelete(&sim2);
-      pDelete(&pm1);
-      pDelete(&m1);
-      pDelete(&m2);
+      //pDelete(&sim2);
+      //pDelete(&pm1);
+      //pDelete(&gcd);
+      //pDelete(&m1);
+      //pDelete(&m2);
       return;
     }
     else
     {
-      gcd = p_Copy(pm1, strat->tailRing);
+      gcd = pCopy(pm1);
       pDelete(&pm1);
       pDelete(&sim2);
@@ -1408 +1625 @@
   enterL(&strat->B,&strat->Bl,&strat->Bmax,h,posx);
   kTest_TS(strat);
+  #endif
 }
 
@@ -1415 +1633 @@
 */
 
-BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1)
+BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR, bool redMoraNF)
 {
   number d, s, t;
-  assume(i<=strat->sl);
   assume(atR >= 0);
-  poly m1, m2, gcd;
-
-  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
+  poly m1, m2, gcd,si;
+  if(!redMoraNF)
+  {
+    assume(i<=strat->sl);
+    si = strat->S[i];
+  }
+  else
+  {
+    assume(i<=strat->tl);
+    si = strat->T[i].p;
+  }
+  //printf("\n--------------------------------\n");
+  //pWrite(p);pWrite(si);
+  d = n_ExtGcd(pGetCoeff(p), pGetCoeff(si), &s, &t, currRing->cf);
 
   if (nIsZero(s) || nIsZero(t))  // evtl. durch divBy tests ersetzen
@@ -1432 +1660 @@
   }
 
-  k_GetStrongLeadTerms(p, strat->S[i], currRing, m1, m2, gcd, strat->tailRing);
+  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
   //p_Test(m1,strat->tailRing);
   //p_Test(m2,strat->tailRing);
-  while (! kCheckStrongCreation(atR, m1, i, m2, strat) )
-  {
-    memset(&(strat->P), 0, sizeof(strat->P));
-    kStratChangeTailRing(strat);
-    strat->P = *(strat->R[atR]);
-    p_LmFree(m1, strat->tailRing);
-    p_LmFree(m2, strat->tailRing);
-    p_LmFree(gcd, currRing);
-    k_GetStrongLeadTerms(p, strat->S[i], currRing, m1, m2, gcd, strat->tailRing);
-  }
+  /*if(!redMoraNF)
+  {
+    while (! kCheckStrongCreation(atR, m1, i, m2, strat) )
+    {
+      memset(&(strat->P), 0, sizeof(strat->P));
+      kStratChangeTailRing(strat);
+      strat->P = *(strat->R[atR]);
+      p_LmFree(m1, strat->tailRing);
+      p_LmFree(m2, strat->tailRing);
+      p_LmFree(gcd, currRing);
+      k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
+    }
+  }*/
   pSetCoeff0(m1, s);
   pSetCoeff0(m2, t);
@@ -1450 +1681 @@
   p_Test(m1,strat->tailRing);
   p_Test(m2,strat->tailRing);
-
+  //printf("\n===================================\n");
+  //pWrite(m1);pWrite(m2);pWrite(gcd);
 #ifdef KDEBUG
   if (TEST_OPT_DEBUG)
@@ -1465 +1697 @@
     wrp(p);
     Print("\n strat->S[%d]: ", i);
-    wrp(strat->S[i]);
+    wrp(si);
     PrintS(" ---> ");
   }
 #endif
-
-  pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(p), m1, strat->tailRing), pp_Mult_mm(pNext(strat->S[i]), m2, strat->tailRing), strat->tailRing);
+  
+  pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(p), m1, strat->tailRing), pp_Mult_mm(pNext(si), m2, strat->tailRing), strat->tailRing);
   p_LmDelete(m1, strat->tailRing);
   p_LmDelete(m2, strat->tailRing);
-
 #ifdef KDEBUG
   if (TEST_OPT_DEBUG)
@@ -1488 +1719 @@
   h.pCleardenom();
   strat->initEcart(&h);
-  if (strat->Ll==-1)
-    posx =0;
-  else
-    posx = strat->posInL(strat->L,strat->Ll,&h,strat);
   h.sev = pGetShortExpVector(h.p);
   h.i_r1 = -1;h.i_r2 = -1;
   if (currRing!=strat->tailRing)
-  {
-    if (h.t_p==NULL) /* may already been set by pLdeg() in initEcart */
-      h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
-  }
-  #if 1
-  h.p1 = p;h.p2 = strat->S[i];
-  #endif
-  if (atR >= 0)
+    h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
+  if(!redMoraNF)
+  {
+    #if 1
+    h.p1 = p;h.p2 = strat->S[i];
+    #endif
+    if (atR >= 0)
     {
       h.i_r2 = strat->S_2_R[i];
@@ -1512 +1738 @@
       h.i_r2 = -1;
     }
-  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
+    if (strat->Ll==-1)
+      posx =0;
+    else
+      posx = strat->posInL(strat->L,strat->Ll,&h,strat);
+    enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
+  }
+  else
+  {
+    enterT_strong(h, strat,strat->tl+1);
+  }
+  //#if 1
   #if ADIDEBUG
-  printf("\nThis strong poly was added to L:\n");pWrite(h.p);pWrite(h.p1);pWrite(h.p2);printf("\ni_r1 = %i, i_r2 = %i\n",h.i_r1, h.i_r2);pWrite(strat->T[h.i_r1].p);pWrite(strat->T[h.i_r2].p);
+  printf("\nThis strong poly was added to L:\n");pWrite(h.p);pWrite(h.p1);pWrite(h.p2);
   #endif
   return TRUE;
@@ -3064 +3300 @@
     }
     #if 1
+
     if (new_pair)
     {
@@ -3747 +3984 @@
       && ((iCompH<=strat->syzComp)||(strat->syzComp==0)))
       {
-        enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR);
+        enterOneStrongPoly(j,h,ecart,isFromQ,strat, atR, FALSE);
       }
     }
@@ -3879 +4116 @@
 void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR)
 {
+#if ADIDEBUG
+  PrintS("\nEnter superenterpairs\n");
+  int iii = strat->Ll;
+  printf("\nstrat->tl = %i\n",strat->tl);
+#endif
   assume (rField_is_Ring(currRing));
   // enter also zero divisor * poly, if this is non zero and of smaller degree
   if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
+#if ADIDEBUG
+  if(iii==strat->Ll)
+  {
+    PrintS("\n                enterExtendedSpoly has not changed the list L.\n");
+  }
+  else
+  {
+    PrintLn();
+    PrintS("\n                enterExtendedSpoly changed the list L:\n");
+    for(iii=0;iii<=strat->Ll;iii++)
+    {
+      Print("\n                L[%d]:\n",iii);
+      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
+      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
+      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
+    }
+  }
+  printf("\nstrat->tl = %i\n",strat->tl);
+  iii = strat->Ll;
+#endif
   initenterpairs(h, k, ecart, 0, strat, atR);
+#if ADIDEBUG
+  if(iii==strat->Ll)
+  {
+    PrintS("\n                initenterpairs has not changed the list L.\n");
+  }
+  else
+  {
+    PrintS("\n                initenterpairs changed the list L:\n");
+    for(iii=0;iii<=strat->Ll;iii++)
+    {
+      Print("\n                L[%d]:\n",iii);
+      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
+      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
+      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
+    }
+  }
+  printf("\nstrat->tl = %i\n",strat->tl);
+  iii = strat->Ll;
+#endif
   initenterstrongPairs(h, k, ecart, 0, strat, atR);
+#if ADIDEBUG
+  if(iii==strat->Ll)
+  {
+    PrintS("\n                initenterstrongPairs has not changed the list L.\n");
+  }
+  else
+  {
+    PrintS("\n                initenterstrongPairs changed the list L:\n");
+    for(iii=0;iii<=strat->Ll;iii++)
+    {
+      Print("\n                L[%d]:\n",iii);
+      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
+      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
+      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
+    }
+  }
+  printf("\nstrat->tl = %i\n",strat->tl);
+  PrintS("\nEnd of superenterpairs\n");
+#endif
   clearSbatch(h, k, pos, strat);
+#if ADIDEBUG
+  printf("\nstrat->tl = %i\n",strat->tl);
+#endif
 }
 #endif
@@ -3899 +4202 @@
   assume (!rField_is_Ring(currRing));
 #endif
+  #if ADIDEBUG
+        Print("\n    Vor initenterpairs: The new pair list L -- after superenterpairs in loop\n");
+        for(int iii=0;iii<=strat->Ll;iii++)
+        {
+          printf("\n    L[%d]:\n",iii);
+          PrintS("         ");p_Write(strat->L[iii].p,strat->tailRing);
+          PrintS("         ");p_Write(strat->L[iii].p1,strat->tailRing);
+          PrintS("         ");p_Write(strat->L[iii].p2,strat->tailRing);
+        }
+        #endif
+
   initenterpairs(h,k,ecart,0,strat, atR);
+
+      #if ADIDEBUG
+        Print("\n    Nach initenterpairs: The new pair list L -- after superenterpairs in loop \n");
+        for(int iii=0;iii<=strat->Ll;iii++)
+        {
+          printf("\n    L[%d]:\n",iii);
+          PrintS("         ");p_Write(strat->L[iii].p,strat->tailRing);
+          PrintS("         ");p_Write(strat->L[iii].p1,strat->tailRing);
+          PrintS("         ");p_Write(strat->L[iii].p2,strat->tailRing);
+        }
+        #endif
+
   if ( (!strat->fromT)
   && ((strat->syzComp==0)
@@ -3912 +4238 @@
       j++;
     }
-  }
+    //Print("end clearS sl=%d\n",strat->sl);
+  }
+ // PrintS("end enterpairs\n");
 }
 
@@ -7697 +8025 @@
   }
 #endif
+
 #ifdef HAVE_TAIL_RING
   if (currRing!=strat->tailRing)
@@ -7735 +8064 @@
   }
   strat->T[atT] = (TObject) p;
+  #if ADIDEBUG
+  printf("\nenterT: add in position %i\n",atT);
+  pWrite(p.p);
+  #endif
+  //printf("\nenterT: neue hingefÌgt: lÀnge = %i, ecart = %i\n",p.length,p.ecart);
 
   if (strat->tailRing != currRing && pNext(p.p) != NULL)
@@ -7746 +8080 @@
   assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
   strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing) && 
+  rHasLocalOrMixedOrdering(currRing) && !n_IsUnit(p.p->coef, currRing->cf))
+  {
+    #if ADIDEBUG_NF
+    printf("\nDas ist p:\n");pWrite(p.p);
+    #endif
+    for(i=strat->tl;i>=0;i--)
+    {
+      if(strat->T[i].ecart <= p.ecart && pLmDivisibleBy(strat->T[i].p,p.p))
+      {
+        #if ADIDEBUG_NF
+        printf("\nFound one: %i\n",i);pWrite(strat->T[i].p);
+        #endif
+        enterOneStrongPoly(i,p.p,p.ecart,0,strat,0 , TRUE);
+      }
+    }
+  }
+  /*
+  printf("\nThis is T:\n");
+  for(i=strat->tl;i>=0;i--)
+  {
+    pWrite(strat->T[i].p);
+  }
+  //getchar();*/
+#endif
+  kTest_T(&(strat->T[atT]));
+}
+
+/*2
+* puts p to the set T at position atT
+*/
+void enterT_strong(LObject &p, kStrategy strat, int atT)
+{
+  int i;
+
+  pp_Test(p.p, currRing, p.tailRing);
+  assume(strat->tailRing == p.tailRing);
+  // redMoraNF complains about this -- but, we don't really
+  // neeed this so far
+  assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
+  assume(p.FDeg == p.pFDeg());
+  assume(!p.is_normalized || nIsOne(pGetCoeff(p.p)));
+
+#ifdef KDEBUG
+  // do not put an LObject twice into T:
+  for(i=strat->tl;i>=0;i--)
+  {
+    if (p.p==strat->T[i].p)
+    {
+      printf("already in T at pos %d of %d, atT=%d\n",i,strat->tl,atT);
+      return;
+    }
+  }
+#endif
+
+#ifdef HAVE_TAIL_RING
+  if (currRing!=strat->tailRing)
+  {
+    p.t_p=p.GetLmTailRing();
+  }
+#endif
+  strat->newt = TRUE;
+  if (atT < 0)
+    atT = strat->posInT(strat->T, strat->tl, p);
+  if (strat->tl == strat->tmax-1)
+    enlargeT(strat->T,strat->R,strat->sevT,strat->tmax,setmaxTinc);
+  if (atT <= strat->tl)
+  {
+#ifdef ENTER_USE_MEMMOVE
+    memmove(&(strat->T[atT+1]), &(strat->T[atT]),
+            (strat->tl-atT+1)*sizeof(TObject));
+    memmove(&(strat->sevT[atT+1]), &(strat->sevT[atT]),
+            (strat->tl-atT+1)*sizeof(unsigned long));
+#endif
+    for (i=strat->tl+1; i>=atT+1; i--)
+    {
+#ifndef ENTER_USE_MEMMOVE
+      strat->T[i] = strat->T[i-1];
+      strat->sevT[i] = strat->sevT[i-1];
+#endif
+      strat->R[strat->T[i].i_r] = &(strat->T[i]);
+    }
+  }
+
+  if ((strat->tailBin != NULL) && (pNext(p.p) != NULL))
+  {
+    pNext(p.p)=p_ShallowCopyDelete(pNext(p.p),
+                                   (strat->tailRing != NULL ?
+                                    strat->tailRing : currRing),
+                                   strat->tailBin);
+    if (p.t_p != NULL) pNext(p.t_p) = pNext(p.p);
+  }
+  strat->T[atT] = (TObject) p;
+  #if ADIDEBUG
+  printf("\nenterT_strong: add in position %i\n",atT);
+  pWrite(p.p);
+  #endif
+  //printf("\nenterT_strong: neue hingefÌgt: lÀnge = %i, ecart = %i\n",p.length,p.ecart);
+
+  if (strat->tailRing != currRing && pNext(p.p) != NULL)
+    strat->T[atT].max = p_GetMaxExpP(pNext(p.p), strat->tailRing);
+  else
+    strat->T[atT].max = NULL;
+
+  strat->tl++;
+  strat->R[strat->tl] = &(strat->T[atT]);
+  strat->T[atT].i_r = strat->tl;
+  assume(p.sev == 0 || pGetShortExpVector(p.p) == p.sev);
+  strat->sevT[atT] = (p.sev == 0 ? pGetShortExpVector(p.p) : p.sev);
+  #if 0
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing) && !n_IsUnit(p.p->coef, currRing->cf))
+  {
+    #if ADIDEBUG_NF
+    printf("\nDas ist p:\n");pWrite(p.p);
+    #endif
+    for(i=strat->tl;i>=0;i--)
+    {
+      if(strat->T[i].ecart <= p.ecart && pLmDivisibleBy(strat->T[i].p,p.p))
+      {
+        #if ADIDEBUG_NF
+        printf("\nFound one: %i\n",i);pWrite(strat->T[i].p);
+        #endif
+        enterOneStrongPoly(i,p.p,p.ecart,0,strat,0 , TRUE);
+      }
+    }
+  }
+  /*
+  printf("\nThis is T:\n");
+  for(i=strat->tl;i>=0;i--)
+  {
+    pWrite(strat->T[i].p);
+  }
+  //getchar();*/
+  #endif
+  #endif
   kTest_T(&(strat->T[atT]));
 }
@@ -8156 +8627 @@
     updateS(TRUE,strat);
   }
-  //if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
-  //strat->fromQ=NULL;
+  if (strat->fromQ!=NULL) omFreeSize(strat->fromQ,IDELEMS(strat->Shdl)*sizeof(int));
+  strat->fromQ=NULL;
   assume(kTest_TS(strat));
 }
@@ -8790 +9261 @@
   if((posconst != -1) && (!nIsZero(F->m[posconst]->coef)))
   {
-      //pDelete(&pmon);
+      pmon = pCopy(F->m[posconst]);
       idDelete(&F);
-      //idDelete(&monred);
-      return NULL;
+      idDelete(&monred);
+      return pmon;
   }
   int idelemQ = 0;
@@ -8809 +9280 @@
       if((posconst != -1) && (!nIsZero(monred->m[posconst]->coef)))
       {
+          pmon = pCopy(monred->m[posconst]);
           idDelete(&F);
           idDelete(&monred);
-          return NULL;
+          return pmon;
       }
   }
@@ -8835 +9307 @@
               II->m[i+1] = II->m[i];
       II->m[0] = pOne();
-      ideal syz = idSyzygies(II, isNotHomog, NULL); 
-      //idPrint(syz);
+      ideal syz = idSyzygies(II, isNotHomog, NULL);     
       poly integer = NULL;
       for(int i = IDELEMS(syz)-1;i>=0; i--)
@@ -8842 +9313 @@
           if(pGetComp(syz->m[i]) == 1)
           {
-              integer = pHead(syz->m[i]);
-              pSetComp(integer,0);
-              if(pIsConstant(integer))
+              if(pIsConstant(syz->m[i]))
               {
+                  integer = pHead(syz->m[i]);
+                  pSetComp(integer, 0);
                   break;
               }
@@ -8854 +9325 @@
       pmon = prMapR(integer, nMap2, QQ_ring, origR);
       idDelete(&F);
-      //idDelete(&monred);
-      //idDelete(&II);
-      //idDelete(&one);
-      //idDelete(&syz);
-      //pDelete(&integer);
+      idDelete(&monred);
+      idDelete(&II);
+      idDelete(&one);
+      idDelete(&syz);
+      pDelete(&integer);
       rDelete(QQ_ring);
       return pmon;
@@ -8933 +9404 @@
   }
   idDelete(&F);
-  //idDelete(&monred);
-  //idDelete(&II);
-  //idDelete(&one);
-  //pDelete(&pmon);
+  idDelete(&monred);
+  idDelete(&II);
+  idDelete(&one);
+  pDelete(&pmon);
   rDelete(QQ_ring);
   return NULL;
@@ -8958 +9429 @@
     if(pNext(strat->S[i]) == NULL)
     {
+      //pWrite(p);
+      //pWrite(strat->S[i]);
       while(ok == FALSE)
       {
         if(pLmDivisibleBy(strat->S[i], p))
         {
-          number c = currRing->cf->cfIntMod(p->coef, strat->S[i]->coef, currRing->cf);
-          pSetCoeff(p,c);
+          p->coef = currRing->cf->cfIntMod(p->coef, strat->S[i]->coef, currRing->cf);
         }
         if(nIsZero(p->coef))
@@ -8980 +9452 @@
         if(pLmDivisibleBy(strat->S[i], pp))
         {
-          number c = currRing->cf->cfIntMod(pp->coef, strat->S[i]->coef, currRing->cf);
-          pSetCoeff(pp,c);
+          pp->coef = currRing->cf->cfIntMod(pp->coef, strat->S[i]->coef, currRing->cf);
           if(nIsZero(pp->coef))
           {
@@ -9028 +9499 @@
           if(pLmDivisibleBy(strat->S[j], p))
           {
-            number n = currRing->cf->cfIntMod(p->coef, strat->S[j]->coef, currRing->cf);
-            pSetCoeff(p,n);
+            //nDelete(&(p->coef));
+            p->coef = currRing->cf->cfIntMod(p->coef, strat->S[j]->coef, currRing->cf);
           }
           pp = pNext(p); 
@@ -9042 +9513 @@
                 if(pLmDivisibleBy(strat->S[j], pp))
                 {
-                  number n = currRing->cf->cfIntMod(pp->coef, strat->S[j]->coef, currRing->cf);
-                  pSetCoeff(pp,n);
+                  //nDelete(&(pp->coef));
+                  pp->coef = currRing->cf->cfIntMod(pp->coef, strat->S[j]->coef, currRing->cf);
                   if(nIsZero(pp->coef))
                   {

kernel/GBEngine/kutil.h

@@ -503 +503 @@
 void entersets (LObject h);
 void pairs ();
+BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1, bool redMoraNF = FALSE);
 void message (int i,int* reduc,int* olddeg,kStrategy strat,int red_result);
 void messageStat (int hilbcount,kStrategy strat);
@@ -529 +530 @@
 void enterSyz (LObject &p,kStrategy strat, int atT);
 void enterT (LObject &p,kStrategy strat, int atT = -1);
+void enterT_strong (LObject &p,kStrategy strat, int atT = -1);
 void cancelunit (LObject* p,BOOLEAN inNF=FALSE);
 void HEckeTest (poly pp,kStrategy strat);