Changeset c66a53 in git for kernel

Timestamp:

Jul 16, 2016, 9:42:28 AM (8 years ago)

Author:

Adi Popescu <adi_popescum@…>

Branches:

(u'spielwiese', '4a9821a93ffdc22a6696668bd4f6b8c9de3e6c5f')

Children:

b6f42a8c2492312d1dd4f0c4c917fcf054636416

Parents:

1798a00a38186e92d8d8d6dc786ccdf6aad508cd34183abab486cee38d70559e5cdcfbc307938f64

Message:

Merge branch 'spielwiese' of github.com:Singular/Sources into SigDrop

Location:

kernel

Files:

• GBEngine/f5gb.cc (modified) (3 diffs)
• GBEngine/kspoly.cc (modified) (7 diffs)
• GBEngine/kstd1.cc (modified) (2 diffs)
• GBEngine/kstd2.cc (modified) (43 diffs)
• GBEngine/kutil.cc (modified) (59 diffs)
• GBEngine/kutil.h (modified) (7 diffs)
• GBEngine/nc.cc (modified) (1 diff)
• GBEngine/syz1.cc (modified) (1 diff)
• GBEngine/syz3.cc (modified) (1 diff)
• ideals.h (modified) (1 diff)
• numeric/mpr_base.cc (modified) (1 diff)
• polys.h (modified) (1 diff)

kernel/GBEngine/f5gb.cc

@@ -29 +29 @@
 #include <kernel/GBEngine/f5data.h>
 #include <kernel/GBEngine/f5lists.h>
+#include <kernel/oswrapper/timer.h>
+
+#define pDeg(A) p_Deg(A,currRing)
+
 int notInG              =   0;
 int numberOfRules       =   0;
@@ -49 +53 @@
 ====================================================================
 */
-void qsortDegree(poly* left, poly* right) {
+void qsortDegree(poly* left, poly* right)
+{
     poly* ptr1 = left;
     poly* ptr2 = right;
     poly p1,p2;
     p2 = *(left + (right - left >> 1));
-    do {
-            while(pTotaldegree(*ptr1, currRing) < pTotaldegree(p2, currRing)) {
+    do
+    {
+            while(p_Totaldegree(*ptr1, currRing) < p_Totaldegree(p2, currRing))
+            {
                     ptr1++;
             }
-            while(pTotaldegree(*ptr2, currRing) > pTotaldegree(p2,currRing)) {
+            while(p_Totaldegree(*ptr2, currRing) > p_Totaldegree(p2,currRing))
+            {
                     ptr2--;
             }
-            if(ptr1 > ptr2) {
+            if(ptr1 > ptr2)
+            {
                     break;
             }
@@ -69 +78 @@
     } while(++ptr1 <= --ptr2);
 
-    if(left < ptr2) {
+    if(left < ptr2)
+    {
             qsortDegree(left,ptr2);
     }
-    if(ptr1 < right) {
+    if(ptr1 < right)
+    {
             qsortDegree(ptr1,right);
     }

kernel/GBEngine/kspoly.cc

@@ -22 +22 @@
 #include <kernel/polys.h>
 #endif
+
+#define ADIDEBUG 0
 
 #ifdef KDEBUG
@@ -180 +182 @@
                  kStrategy strat)
 {
+#if ADIDEBUG
+printf("\nksReducePolySig\n");
+pWrite(PR->p);pWrite(PR->sig);
+pWrite(PW->p);pWrite(PW->sig);
+#endif
 #ifdef KDEBUG
   red_count++;
@@ -235 +242 @@
 #endif
     p_ExpVectorAddSub(sigMult,PR->GetLmCurrRing(),PW->GetLmCurrRing(),currRing);
+    //I have also to set the leading coeficient for sigMult (in the case of rings)
+    if(rField_is_Ring(currRing))
+    {
+      pSetCoeff(sigMult,nMult(nDiv(pGetCoeff(PR->p),pGetCoeff(PW->p)), pGetCoeff(sigMult)));
+    }
 //#if 1
 #ifdef DEBUGF5
@@ -244 +256 @@
     printf("--------------\n");
 #endif
-    int sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
+    int sigSafe;
+    if(!rField_is_Ring(currRing))
+      sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
     // now we can delete the copied polynomial data used for checking for
     // sig-safeness of the reduction step
@@ -252 +266 @@
 
 #endif
+    if(rField_is_Ring(currRing))
+    {
+      // Set the sig
+      poly origsig = pCopy(PR->sig);
+      PR->sig = pHead(pSub(PR->sig, sigMult));
+      //The sigs have the same lm, have to substract
+      //It may happen that now the signature is 0 (drop)
+      if(PR->sig == NULL)
+      {
+        #if ADIDEBUG
+        printf("\nPossible sigdrop in ksreducepolysig (lost signature)\n");
+        #endif
+        strat->sigdrop=TRUE;
+      }
+      else
+      {
+        if(pLtCmp(PR->sig,origsig) == 1)
+        {
+          // do not allow this reduction - it will increase it's signature
+          // and the partially standard basis is just till the old sig, not the new one
+          PR->is_redundant = TRUE;
+          pDelete(&PR->sig);
+          PR->sig = origsig;
+          strat->blockred++;
+          return 3;
+        }
+        if(pLtCmp(PR->sig,origsig) == -1)
+        {
+          #if ADIDEBUG
+          printf("\nSigdrop in ksreducepolysig from * to *\n");pWrite(origsig);pWrite(PR->sig);
+          #endif
+          strat->sigdrop=TRUE;
+        }
+      }
+      pDelete(&origsig);
+    }
     //pDelete(&f1);
-    pDelete(&sigMult);
     // go on with the computations only if the signature of p2 is greater than the
     // signature of fm*p1
-    if(sigSafe != 1)
+    if(sigSafe != 1 && !rField_is_Ring(currRing))
     {
       PR->is_redundant = TRUE;
@@ -324 +373 @@
     }
   }
-
   // take care of coef buisness
-  if (! n_IsOne(pGetCoeff(p2), tailRing))
-  {
-    number bn = pGetCoeff(lm);
-    number an = pGetCoeff(p2);
-    int ct = ksCheckCoeff(&an, &bn, tailRing->cf);    // Calculate special LC
-    p_SetCoeff(lm, bn, tailRing);
-    if ((ct == 0) || (ct == 2))
-      PR->Tail_Mult_nn(an);
-    if (coef != NULL) *coef = an;
-    else n_Delete(&an, tailRing);
+  if(rField_is_Ring(currRing))
+  {
+    p_SetCoeff(lm, nDiv(pGetCoeff(lm),pGetCoeff(p2)), tailRing);
+    if (coef != NULL) *coef = n_Init(1, tailRing);
   }
   else
   {
-    if (coef != NULL) *coef = n_Init(1, tailRing);
-  }
-
+    if (! n_IsOne(pGetCoeff(p2), tailRing))
+    {
+      number bn = pGetCoeff(lm);
+      number an = pGetCoeff(p2);
+      int ct = ksCheckCoeff(&an, &bn, tailRing->cf);    // Calculate special LC
+      p_SetCoeff(lm, bn, tailRing);
+      if (((ct == 0) || (ct == 2)))
+        PR->Tail_Mult_nn(an);
+      if (coef != NULL) *coef = an;
+      else n_Delete(&an, tailRing);
+    }
+    else
+    {
+      if (coef != NULL) *coef = n_Init(1, tailRing);
+    }
+  }
 
   // and finally,
@@ -361 +416 @@
   }
 #endif
-
 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
   if (TEST_OPT_DEBUG)

kernel/GBEngine/kstd1.cc

@@ -1508 +1508 @@
     strat->red2 = redHomog;
   }
-#if defined(HAVE_RINGS)
   if (rField_is_Ring(currRing))
   {
     if(rHasLocalOrMixedOrdering(currRing))
-      {strat->red = redRiloc;}
+      {strat->red2 = redRiloc;}
     else
       {strat->red2 = redRing;}
   }
-#endif
   if (currRing->pLexOrder && strat->honey)
     strat->initEcart = initEcartNormal;
@@ -2452 +2450 @@
           int newIdeal, intvec *vw)
 {
-  if(idIs0(F))
-    return idInit(1,F->rank);
-
-  ideal r;
-  BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
-  BOOLEAN delete_w=(w==NULL);
-  kStrategy strat=new skStrategy;
-  strat->sbaOrder = sbaOrder;
-  if (arri!=0)
-  {
-    strat->rewCrit1 = arriRewDummy;
-    strat->rewCrit2 = arriRewCriterion;
-    strat->rewCrit3 = arriRewCriterionPre;
+  if(!rField_is_Ring(currRing))
+  {
+    if(idIs0(F))
+      return idInit(1,F->rank);
+
+    ideal r;
+    BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
+    BOOLEAN delete_w=(w==NULL);
+    kStrategy strat=new skStrategy;
+    strat->sbaOrder = sbaOrder;
+    if (arri!=0)
+    {
+      strat->rewCrit1 = arriRewDummy;
+      strat->rewCrit2 = arriRewCriterion;
+      strat->rewCrit3 = arriRewCriterionPre;
+    }
+    else
+    {
+      strat->rewCrit1 = faugereRewCriterion;
+      strat->rewCrit2 = faugereRewCriterion;
+      strat->rewCrit3 = faugereRewCriterion;
+    }
+
+    if(!TEST_OPT_RETURN_SB)
+      strat->syzComp = syzComp;
+    if (TEST_OPT_SB_1)
+      if(!rField_is_Ring(currRing))
+        strat->newIdeal = newIdeal;
+    if (rField_has_simple_inverse(currRing))
+      strat->LazyPass=20;
+    else
+      strat->LazyPass=2;
+    strat->LazyDegree = 1;
+    strat->enterOnePair=enterOnePairNormal;
+    strat->chainCrit=chainCritNormal;
+    if (TEST_OPT_SB_1) strat->chainCrit=chainCritOpt_1;
+    strat->ak = id_RankFreeModule(F,currRing);
+    strat->kModW=kModW=NULL;
+    strat->kHomW=kHomW=NULL;
+    if (vw != NULL)
+    {
+      currRing->pLexOrder=FALSE;
+      strat->kHomW=kHomW=vw;
+      strat->pOrigFDeg = currRing->pFDeg;
+      strat->pOrigLDeg = currRing->pLDeg;
+      pSetDegProcs(currRing,kHomModDeg);
+      toReset = TRUE;
+    }
+    if (h==testHomog)
+    {
+      if (strat->ak == 0)
+      {
+        h = (tHomog)idHomIdeal(F,Q);
+        w=NULL;
+      }
+      else if (!TEST_OPT_DEGBOUND)
+      {
+        h = (tHomog)idHomModule(F,Q,w);
+      }
+    }
+    currRing->pLexOrder=b;
+    if (h==isHomog)
+    {
+      if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
+      {
+        strat->kModW = kModW = *w;
+        if (vw == NULL)
+        {
+          strat->pOrigFDeg = currRing->pFDeg;
+          strat->pOrigLDeg = currRing->pLDeg;
+          pSetDegProcs(currRing,kModDeg);
+          toReset = TRUE;
+        }
+      }
+      currRing->pLexOrder = TRUE;
+      if (hilb==NULL) strat->LazyPass*=2;
+    }
+    strat->homog=h;
+  #ifdef KDEBUG
+    idTest(F);
+    if(Q != NULL)
+      idTest(Q);
+  #endif
+  #ifdef HAVE_PLURAL
+    if (rIsPluralRing(currRing))
+    {
+      const BOOLEAN bIsSCA  = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
+      strat->no_prod_crit   = ! bIsSCA;
+      if (w!=NULL)
+        r = nc_GB(F, Q, *w, hilb, strat, currRing);
+      else
+        r = nc_GB(F, Q, NULL, hilb, strat, currRing);
+    }
+    else
+  #endif
+    {
+      if (rHasLocalOrMixedOrdering(currRing))
+      {
+        if (w!=NULL)
+          r=mora(F,Q,*w,hilb,strat);
+        else
+          r=mora(F,Q,NULL,hilb,strat);
+      }
+      else
+      {
+        if (w!=NULL)
+          r=sba(F,Q,*w,hilb,strat);
+        else
+          r=sba(F,Q,NULL,hilb,strat);
+      }
+    }
+  #ifdef KDEBUG
+    idTest(r);
+  #endif
+    if (toReset)
+    {
+      kModW = NULL;
+      pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
+    }
+    currRing->pLexOrder = b;
+  //Print("%d reductions canceled \n",strat->cel);
+    HCord=strat->HCord;
+    //delete(strat);
+    if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
+    return r;
   }
   else
   {
-    strat->rewCrit1 = faugereRewCriterion;
-    strat->rewCrit2 = faugereRewCriterion;
-    strat->rewCrit3 = faugereRewCriterion;
-  }
-
-  if(!TEST_OPT_RETURN_SB)
-    strat->syzComp = syzComp;
-  if (TEST_OPT_SB_1)
-    if(!rField_is_Ring(currRing))
-      strat->newIdeal = newIdeal;
-  if (rField_has_simple_inverse(currRing))
-    strat->LazyPass=20;
-  else
-    strat->LazyPass=2;
-  strat->LazyDegree = 1;
-  strat->enterOnePair=enterOnePairNormal;
-  strat->chainCrit=chainCritNormal;
-  if (TEST_OPT_SB_1) strat->chainCrit=chainCritOpt_1;
-  strat->ak = id_RankFreeModule(F,currRing);
-  strat->kModW=kModW=NULL;
-  strat->kHomW=kHomW=NULL;
-  if (vw != NULL)
-  {
-    currRing->pLexOrder=FALSE;
-    strat->kHomW=kHomW=vw;
-    strat->pOrigFDeg = currRing->pFDeg;
-    strat->pOrigLDeg = currRing->pLDeg;
-    pSetDegProcs(currRing,kHomModDeg);
-    toReset = TRUE;
-  }
-  if (h==testHomog)
-  {
-    if (strat->ak == 0)
-    {
-      h = (tHomog)idHomIdeal(F,Q);
-      w=NULL;
-    }
-    else if (!TEST_OPT_DEGBOUND)
-    {
-      h = (tHomog)idHomModule(F,Q,w);
-    }
-  }
-  currRing->pLexOrder=b;
-  if (h==isHomog)
-  {
-    if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
-    {
-      strat->kModW = kModW = *w;
-      if (vw == NULL)
-      {
+    //--------------------------RING CASE-------------------------
+    if(idIs0(F))
+      return idInit(1,F->rank);
+    ideal r;
+    r = idCopy(F);
+    int sbaEnterS = -1;
+    bool sigdrop = TRUE;
+    #if ADIDEBUG
+    printf("\nEnter the nice kSba loop\n");
+    #endif
+    //This is how we set the SBA algorithm;
+    int totalsbaruns = 1,blockedreductions = 10,blockred = 0,loops = 0;
+    while(sigdrop && (loops < totalsbaruns || totalsbaruns == -1) 
+                  && (blockred <= blockedreductions))
+    {
+      loops++;
+      if(loops == 1)
+        sigdrop = FALSE;
+      BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
+      BOOLEAN delete_w=(w==NULL);
+      kStrategy strat=new skStrategy;
+      strat->sbaEnterS = sbaEnterS;
+      strat->sigdrop = sigdrop;
+      #if 0
+      strat->blockred = blockred;
+      #else
+      strat->blockred = 0;
+      #endif
+      strat->blockredmax = blockedreductions;
+      //printf("\nsbaEnterS beginning = %i\n",strat->sbaEnterS);
+      //printf("\nsigdrop beginning = %i\n",strat->sigdrop);
+      strat->sbaOrder = sbaOrder;
+      if (arri!=0)
+      {
+        strat->rewCrit1 = arriRewDummy;
+        strat->rewCrit2 = arriRewCriterion;
+        strat->rewCrit3 = arriRewCriterionPre;
+      }
+      else
+      {
+        strat->rewCrit1 = faugereRewCriterion;
+        strat->rewCrit2 = faugereRewCriterion;
+        strat->rewCrit3 = faugereRewCriterion;
+      }
+
+      if(!TEST_OPT_RETURN_SB)
+        strat->syzComp = syzComp;
+      if (TEST_OPT_SB_1)
+        if(!rField_is_Ring(currRing))
+          strat->newIdeal = newIdeal;
+      if (rField_has_simple_inverse(currRing))
+        strat->LazyPass=20;
+      else
+        strat->LazyPass=2;
+      strat->LazyDegree = 1;
+      strat->enterOnePair=enterOnePairNormal;
+      strat->chainCrit=chainCritNormal;
+      if (TEST_OPT_SB_1) strat->chainCrit=chainCritOpt_1;
+      strat->ak = id_RankFreeModule(F,currRing);
+      strat->kModW=kModW=NULL;
+      strat->kHomW=kHomW=NULL;
+      if (vw != NULL)
+      {
+        currRing->pLexOrder=FALSE;
+        strat->kHomW=kHomW=vw;
         strat->pOrigFDeg = currRing->pFDeg;
         strat->pOrigLDeg = currRing->pLDeg;
-        pSetDegProcs(currRing,kModDeg);
+        pSetDegProcs(currRing,kHomModDeg);
         toReset = TRUE;
       }
-    }
-    currRing->pLexOrder = TRUE;
-    if (hilb==NULL) strat->LazyPass*=2;
-  }
-  strat->homog=h;
-#ifdef KDEBUG
-  idTest(F);
-  idTest(Q);
-#endif
-#ifdef HAVE_PLURAL
-  if (rIsPluralRing(currRing))
-  {
-    const BOOLEAN bIsSCA  = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
-    strat->no_prod_crit   = ! bIsSCA;
-    if (w!=NULL)
-      r = nc_GB(F, Q, *w, hilb, strat, currRing);
-    else
-      r = nc_GB(F, Q, NULL, hilb, strat, currRing);
-  }
-  else
-#endif
-  if (rField_is_Ring(currRing))
-    r=bba(F,Q,NULL,hilb,strat);
-  else
-  {
-    if (rHasLocalOrMixedOrdering(currRing))
-    {
-      if (w!=NULL)
-        r=mora(F,Q,*w,hilb,strat);
+      if (h==testHomog)
+      {
+        if (strat->ak == 0)
+        {
+          h = (tHomog)idHomIdeal(F,Q);
+          w=NULL;
+        }
+        else if (!TEST_OPT_DEGBOUND)
+        {
+          h = (tHomog)idHomModule(F,Q,w);
+        }
+      }
+      currRing->pLexOrder=b;
+      if (h==isHomog)
+      {
+        if (strat->ak > 0 && (w!=NULL) && (*w!=NULL))
+        {
+          strat->kModW = kModW = *w;
+          if (vw == NULL)
+          {
+            strat->pOrigFDeg = currRing->pFDeg;
+            strat->pOrigLDeg = currRing->pLDeg;
+            pSetDegProcs(currRing,kModDeg);
+            toReset = TRUE;
+          }
+        }
+        currRing->pLexOrder = TRUE;
+        if (hilb==NULL) strat->LazyPass*=2;
+      }
+      strat->homog=h;
+    #ifdef KDEBUG
+      idTest(F);
+      if(Q != NULL)
+        idTest(Q);
+    #endif
+    #ifdef HAVE_PLURAL
+      if (rIsPluralRing(currRing))
+      {
+        const BOOLEAN bIsSCA  = rIsSCA(currRing) && strat->z2homog; // for Z_2 prod-crit
+        strat->no_prod_crit   = ! bIsSCA;
+        if (w!=NULL)
+          r = nc_GB(F, Q, *w, hilb, strat, currRing);
+        else
+          r = nc_GB(F, Q, NULL, hilb, strat, currRing);
+      }
       else
-        r=mora(F,Q,NULL,hilb,strat);
-    }
-    else
-    {
-      if (w!=NULL)
-        r=sba(F,Q,*w,hilb,strat);
-      else
-        r=sba(F,Q,NULL,hilb,strat);
-    }
-  }
-#ifdef KDEBUG
-  idTest(r);
-#endif
-  if (toReset)
-  {
-    kModW = NULL;
-    pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
-  }
-  currRing->pLexOrder = b;
-//Print("%d reductions canceled \n",strat->cel);
-  HCord=strat->HCord;
-  delete(strat);
-  if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
-  return r;
+    #endif
+      {
+        if (rHasLocalOrMixedOrdering(currRing))
+        {
+          if (w!=NULL)
+            r=mora(F,Q,*w,hilb,strat);
+          else
+            r=mora(F,Q,NULL,hilb,strat);
+        }
+        else
+        {
+          if (w!=NULL)
+            r=sba(r,Q,*w,hilb,strat);
+          else
+          { 
+            r=sba(r,Q,NULL,hilb,strat);
+          }
+          #if ADIDEBUG
+          printf("\nSBA Run %i: %i elements (syzCrit = %i,rewCrit = %i)\n",loops,IDELEMS(r),strat->nrsyzcrit,strat->nrrewcrit);
+          idPrint(r);
+          getchar();
+          #endif
+        }
+      }
+    #ifdef KDEBUG
+      idTest(r);
+    #endif
+      if (toReset)
+      {
+        kModW = NULL;
+        pRestoreDegProcs(currRing,strat->pOrigFDeg, strat->pOrigLDeg);
+      }
+      currRing->pLexOrder = b;
+    //Print("%d reductions canceled \n",strat->cel);
+      HCord=strat->HCord;
+      sigdrop = strat->sigdrop;
+      sbaEnterS = strat->sbaEnterS;
+      blockred = strat->blockred;
+      #if ADIDEBUG
+      printf("\nsbaEnterS = %i\n",sbaEnterS);
+      #endif
+      delete(strat);
+      if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
+    }
+    // Go to std
+    if(sigdrop || blockred > blockedreductions)
+    {
+      #if ADIDEBUG
+      printf("\nWent to std\n");
+      //idPrint(r);
+      //getchar();
+      #endif
+      r = kStd(r, Q, h, w, hilb, syzComp, newIdeal, vw);
+    }
+    return r;
+  }
 }
 

kernel/GBEngine/kstd2.cc

@@ -8 +8 @@
 // #define PDEBUG 2
 
-
-
-
-
 #include <kernel/mod2.h>
 
 #define ADIDEBUG 0
 #define ADIDEBUG_COUNT 0
+#define GCD_SBA 1
 
 // define if no buckets should be used
@@ -104 +101 @@
     pAssume(~not_sev == p_GetShortExpVector(p, r));
 
-#ifdef HAVE_RINGS
     if(rField_is_Ring(r))
     {
@@ -147 +143 @@
       }
     }
-#endif
   }
   else
@@ -153 +148 @@
     const poly p=L->t_p;
     const ring r=strat->tailRing;
-#ifdef HAVE_RINGS
     if(rField_is_Ring(r))
     {
@@ -178 +172 @@
     }
     else
-#endif
     {
       loop
@@ -483 +476 @@
       }
     }
+    //printf("\nFound one: ");pWrite(strat->T[j].p);
     //enterT(*h, strat);
     ksReducePoly(h, &(strat->T[j]), NULL, NULL, strat); // with debug output
-
+    //printf("\nAfter small red: ");pWrite(h->p);
     if (h->GetLmTailRing() == NULL)
     {
@@ -668 +662 @@
 }
 
-KINLINE int ksReducePolyTailSig(LObject* PR, TObject* PW, LObject* Red)
+KINLINE int ksReducePolyTailSig(LObject* PR, TObject* PW, LObject* Red, kStrategy strat)
 {
   BOOLEAN ret;
   number coef;
-
   assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
-  Red->HeadNormalize();
+  if(!rField_is_Ring(currRing))
+    Red->HeadNormalize();
   /*
   printf("------------------------\n");
   pWrite(Red->GetLmCurrRing());
   */
-  ret = ksReducePolySig(Red, PW, 1, NULL, &coef);
-
-
+  ret = ksReducePolySig(Red, PW, 1, NULL, &coef, strat);
   if (!ret)
   {
-    if (! n_IsOne(coef, currRing->cf))
+    if (! n_IsOne(coef, currRing->cf) && !rField_is_Ring(currRing))
     {
       PR->Mult_nn(coef);
@@ -706 +698 @@
 int redSig (LObject* h,kStrategy strat)
 {
+  //Since reduce is really bad for SBA we use the following idea:
+  // We first check if we can build a gcd pair between h and S
+  //where the sig remains the same and replace h by this gcd poly
+  #if GCD_SBA
+  #if ADIDEBUG
+  printf("\nBefore sbaCheckGcdPair ");pWrite(h->p);
+  #endif
+  //sbaCheckGcdPair(h,strat);
+  while(sbaCheckGcdPair(h,strat)) 
+  {
+    #if ADIDEBUG
+    printf("\nIntermidiate sbaCheckGcdPair ");pWrite(h->p);
+    #endif
+    h->sev = pGetShortExpVector(h->p);
+  }
+  #if ADIDEBUG
+  printf("\nAfter sbaCheckGcdPair ");pWrite(h->p);
+  #endif
+  #endif
+  #ifdef HAVE_RINGS
+  poly beforeredsig;
+  if(rField_is_Ring(currRing)) 
+    beforeredsig = pCopy(h->sig);
+  #endif
   if (strat->tl<0) return 1;
   //if (h->GetLmTailRing()==NULL) return 0; // HS: SHOULD NOT BE NEEDED!
   //printf("FDEGS: %ld -- %ld\n",h->FDeg, h->pFDeg());
   assume(h->FDeg == h->pFDeg());
+  #if ADIDEBUG
+  printf("\n--------------------------redSig-------------------------------------\n");
+  printf("\nBefore redSig:\n");
+  p_Write(h->p,strat->tailRing);pWrite(h->sig);
+  #endif
 //#if 1
 #ifdef DEBUGF5
@@ -739 +760 @@
     if (j < 0)
     {
-      return 1;
+      #if GCD_SBA
+      #if ADIDEBUG
+      printf("\nBefore sbaCheckGcdPair ");pWrite(h->p);
+      #endif
+      //sbaCheckGcdPair(h,strat);
+      while(sbaCheckGcdPair(h,strat)) 
+      {
+        #if ADIDEBUG
+        printf("\nIntermidiate sbaCheckGcdPair ");pWrite(h->p);
+        #endif
+        h->sev = pGetShortExpVector(h->p);
+        h->is_redundant = FALSE;
+        start = 0;
+      }
+      #if ADIDEBUG
+      printf("\nAfter sbaCheckGcdPair ");pWrite(h->p);
+      #endif
+      #endif
+      // over ZZ: cleanup coefficients by complete reduction with monomials
+      postReduceByMonSig(h, strat);
+      if(h->p == NULL || nIsZero(pGetCoeff(h->p))) return 2;
+      j = kFindDivisibleByInT(strat, h,start);
+      if(j < 0)
+      {
+        if(strat->tl >= 0)
+            h->i_r1 = strat->tl;
+        else
+            h->i_r1 = -1;
+        if (h->GetLmTailRing() == NULL)
+        {
+          if (h->lcm!=NULL) pLmDelete(h->lcm);
+          h->Clear();
+          return 0;
+        }
+        #ifdef HAVE_RINGS
+        if(rField_is_Ring(currRing))
+        {
+          //Check for sigdrop after reduction
+          if(pLtCmp(beforeredsig,h->sig) == 1)
+          {
+            #if ADIDEBUG
+            printf("\nSigDrop after reduce\n");pWrite(beforeredsig);pWrite(h->sig);
+            #endif
+            strat->sigdrop = TRUE;
+            //Reduce it as much as you can
+            int red_result = redRing(h,strat);
+            if(red_result == 0)
+            {
+              //It reduced to 0, cancel the sigdrop
+              #if ADIDEBUG
+              printf("\nReduced to 0 via redRing. Cancel sigdrop\n");
+              #endif
+              strat->sigdrop = FALSE;
+              p_Delete(&h->sig,currRing);h->sig = NULL;
+              return 0;
+            }
+            else
+            {
+              #if ADIDEBUG
+              printf("\nReduced to this via redRing.SIGDROP\n");pWrite(h->p);
+              #endif
+              //strat->enterS(*h, strat->sl+1, strat, strat->tl);
+              return 0;
+            }
+          }
+          p_Delete(&beforeredsig,currRing);
+        }
+        #endif
+        return 1;
+      }
     }
 
@@ -749 +839 @@
      */
     i = j;
-#if 1
     if (TEST_OPT_LENGTH)
-    loop
-    {
-      /*- search the shortest possible with respect to length -*/
-      i++;
-      if (i > strat->tl)
-        break;
-      if (li<=1)
-        break;
-      if ((strat->T[i].pLength < li)
-         &&
-          p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
-                               h_p, not_sev, strat->tailRing))
-      {
-        /*
-         * the polynomial to reduce with is now;
-         */
-        li = strat->T[i].pLength;
-        ii = i;
+    if(rField_is_Ring(currRing))
+    {
+      loop
+      {
+        /*- search the shortest possible with respect to length -*/
+        i++;
+        if (i > strat->tl)
+          break;
+        if (li<=1)
+          break;
+        if ((strat->T[i].pLength < li)
+           && n_DivBy(pGetCoeff(h_p),pGetCoeff(strat->T[i].p),currRing->cf)
+           && p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
+                                 h_p, not_sev, strat->tailRing))
+        {
+          /*
+           * the polynomial to reduce with is now;
+           */
+          li = strat->T[i].pLength;
+          ii = i;
+        }
+      }
+    }
+    else
+    {
+      loop
+      {
+        /*- search the shortest possible with respect to length -*/
+        i++;
+        if (i > strat->tl)
+          break;
+        if (li<=1)
+          break;
+        if ((strat->T[i].pLength < li)
+           && p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
+                                 h_p, not_sev, strat->tailRing))
+        {
+          /*
+           * the polynomial to reduce with is now;
+           */
+          li = strat->T[i].pLength;
+          ii = i;
+        }
       }
     }
     start = ii+1;
-#endif
 
     /*
@@ -800 +913 @@
     printf("INDEX OF REDUCER T: %d\n",ii);
 #endif
+    #if ADIDEBUG
+    printf("\nWe reduce it with:\n");p_Write(strat->T[ii].p,strat->tailRing);pWrite(strat->T[ii].sig);
+    #endif
     sigSafe = ksReducePolySig(h, &(strat->T[ii]), strat->S_2_R[ii], NULL, NULL, strat);
+    #if ADIDEBUG
+    printf("\nAfter small reduction:\n");pWrite(h->p);pWrite(h->sig);
+    #endif
+    if(rField_is_Ring(currRing) && h->p == NULL && h->sig == NULL)
+    {
+      //Trivial case catch
+      strat->sigdrop = FALSE;
+    }
+    #if 0
+    //If the reducer has the same lt (+ or -) as the other one, reduce it via redRing
+    //In some cases this proves to be very bad
+    if(rField_is_Ring(currRing) && h->p != NULL && pLmCmp(h->p,strat->T[ii].p)==0)
+    {
+      #if ADIDEBUG
+      printf("\nReducer and Original have same LT. Force it with redRing!\n");
+      #endif
+      int red_result = redRing(h,strat);
+      if(red_result == 0)
+      {
+        #if ADIDEBUG
+        printf("\nRedRing reduced it to 0. Perfect\n");
+        #endif
+        pDelete(&h->sig);h->sig = NULL;
+        return 0;
+      }
+      else
+      {
+        #if ADIDEBUG
+        printf("\nRedRing reduced it to *.\nHave to sigdrop now\n");pWrite(h->p);
+        #endif
+        strat->sigdrop = TRUE;
+        return 1;
+      }
+    }
+    #endif
+    if(strat->sigdrop)
+      return 1;
 #if SBA_PRINT_REDUCTION_STEPS
     if (sigSafe != 3)
@@ -902 +1055 @@
     loop
     {
+      if(rField_is_Ring(currRing) && strat->sigdrop)
+        break;
       Ln.SetShortExpVector();
       if (withT)
@@ -920 +1075 @@
         cnt=REDTAIL_CANONICALIZE;
         /*poly tmp=*/Ln.CanonicalizeP();
-        if (normalize)
+        if (normalize && !rField_is_Ring(currRing))
         {
           Ln.Normalize();
@@ -927 +1082 @@
         }
       }
-      if (normalize && (!TEST_OPT_INTSTRATEGY) && (!nIsOne(pGetCoeff(With->p))))
+      if (normalize && (!TEST_OPT_INTSTRATEGY) && !rField_is_Ring(currRing) && (!nIsOne(pGetCoeff(With->p))))
       {
         With->pNorm();
       }
       strat->redTailChange=TRUE;
-      int ret = ksReducePolyTailSig(L, With, &Ln);
+      #if ADIDEBUG
+      printf("\nWill TAILreduce * with *:\n");pWrite(Ln.p);pWrite(Ln.sig);
+      pWrite(With->p);pWrite(With->sig);pWrite(L->sig);
+      #endif
+      int ret = ksReducePolyTailSig(L, With, &Ln, strat);
+      if(rField_is_Ring(currRing))
+        L->sig = Ln.sig;
+      //Because Ln.sig is set to L->sig, but in ksReducePolyTailSig -> ksReducePolySig
+      // I delete it an then set Ln.sig. Hence L->sig is lost
+      #if ADIDEBUG
+      printf("\nAfter small TAILreduce:\n");pWrite(Ln.p);pWrite(Ln.sig);pWrite(L->sig);
+      #endif
 #if SBA_PRINT_REDUCTION_STEPS
       if (ret != 3)
@@ -957 +1123 @@
       if (Ln.IsNull()) goto all_done;
       if (! withT) With_s.Init(currRing);
+      if(rField_is_Ring(currRing) && strat->sigdrop)
+      {
+        //Cannot break the loop here so easily
+        break;
+      }
     }
     pNext(h) = Ln.LmExtractAndIter();
     pIter(h);
-    pNormalize(h);
+    if(!rField_is_Ring(currRing))
+      pNormalize(h);
     L->pLength++;
   }
-
   all_done:
   Ln.Delete();
@@ -972 +1143 @@
     L->length = 0;
   }
-
   //if (TEST_OPT_PROT) { PrintS("N"); mflush(); }
   //L->Normalize(); // HANNES: should have a test
@@ -1543 +1713 @@
   while (strat->Ll >= 0)
   {
+    #if ADIDEBUG
+    printf("\n      ------------------------NEW LOOP\n");
+    printf("\nShdl = \n");
+    #if 0
+    idPrint(strat->Shdl);
+    #else
+    for(int ii = 0; ii<=strat->sl;ii++)
+        p_Write(strat->S[ii],strat->tailRing);
+    #endif
+    printf("\n   list   L\n");
+    int iii;
+    #if 1
+    for(iii = 0; iii<= strat->Ll; iii++)
+    {
+        printf("L[%i]:",iii);
+        p_Write(strat->L[iii].p, currRing);
+        p_Write(strat->L[iii].p1, currRing);
+        p_Write(strat->L[iii].p2, currRing);
+    }
+    #else
+    {
+        printf("L[%i]:",strat->Ll);
+        p_Write(strat->L[strat->Ll].p, strat->tailRing);
+        p_Write(strat->L[strat->Ll].p1, strat->tailRing);
+        p_Write(strat->L[strat->Ll].p2, strat->tailRing);
+    }
+    #endif
+    #if 0
+    for(iii = 0; iii<= strat->Bl; iii++)
+    {
+        printf("B[%i]:",iii);
+        p_Write(strat->B[iii].p, /*strat->tailRing*/currRing);
+        p_Write(strat->B[iii].p1, /*strat->tailRing*/currRing);
+        p_Write(strat->B[iii].p2, strat->tailRing);
+    }
+    #endif
+    //getchar();
+    #endif
     #ifdef KDEBUG
       if (TEST_OPT_DEBUG) messageSets(strat);
@@ -1695 +1903 @@
         // posInS only depends on the leading term
         strat->enterS(strat->P, pos, strat, strat->tl);
+        #if ADIDEBUG
+        printf("\nThis element has been added to S:\n");pWrite(strat->P.p);pWrite(strat->P.p1);pWrite(strat->P.p2);
+        #endif
 #if 0
         int pl=pLength(strat->P.p);
@@ -1855 +2066 @@
   sba_interreduction_operations = 0;
 #endif
-
+  
   ideal F1 = F0;
   ring sRing, currRingOld;
@@ -1868 +2079 @@
     }
   }
+  ideal F;
   // sort ideal F
-  ideal F       = idInit(IDELEMS(F1),F1->rank);
-  intvec *sort  = idSort(F1);
-  for (int i=0; i<sort->length();++i)
-    F->m[i] = F1->m[(*sort)[i]-1];
+  //Put the SigDrop element on the correct position (think of sbaEnterS)
+  //We also sort them
+  if(rField_is_Ring(currRing) && strat->sigdrop)
+  {
+    #if 1
+    F = idInit(IDELEMS(F1),F1->rank);
+    for (int i=0; i<IDELEMS(F1);++i)
+      F->m[i] = F1->m[i];
+    if(strat->sbaEnterS >= 0)
+    {
+      poly dummy;
+      dummy = pCopy(F->m[0]); //the sigdrop element
+      for(int i = 0;i<strat->sbaEnterS;i++)
+        F->m[i] = F->m[i+1];
+      F->m[strat->sbaEnterS] = dummy;
+    }
+    #else
+    F = idInit(1,F1->rank);
+    //printf("\nBefore the initial block sorting:\n");idPrint(F1);
+    F->m[0] = F1->m[0];
+    int pos;
+    if(strat->sbaEnterS >= 0)
+    {
+      for(int i=1;i<=strat->sbaEnterS;i++)
+      {
+        pos = posInIdealMonFirst(F,F1->m[i],1,strat->sbaEnterS);
+        idInsertPolyOnPos(F,F1->m[i],pos);
+      }
+      for(int i=strat->sbaEnterS+1;i<IDELEMS(F1);i++)
+      {
+        pos = posInIdealMonFirst(F,F1->m[i],strat->sbaEnterS+1,IDELEMS(F));
+        idInsertPolyOnPos(F,F1->m[i],pos);
+      }
+      poly dummy;
+      dummy = pCopy(F->m[0]); //the sigdrop element
+      for(int i = 0;i<strat->sbaEnterS;i++)
+        F->m[i] = F->m[i+1];
+      F->m[strat->sbaEnterS] = dummy;
+    }
+    else
+    {
+      for(int i=1;i<IDELEMS(F1);i++)
+      {
+        pos = posInIdealMonFirst(F,F1->m[i],1,IDELEMS(F));
+        idInsertPolyOnPos(F,F1->m[i],pos);
+      }
+    }
+    #endif
+    //printf("\nAfter the initial block sorting:\n");idPrint(F);getchar();
+  }
+  else
+  {
+    F       = idInit(IDELEMS(F1),F1->rank);
+    intvec *sort  = idSort(F1);
+    for (int i=0; i<sort->length();++i)
+      F->m[i] = F1->m[(*sort)[i]-1];
+  // put the monomials after the sbaEnterS polynomials
+  //printf("\nThis is the ideal before sorting (sbaEnterS = %i)\n",strat->sbaEnterS);idPrint(F);
+  int nrmon = 0;
+  for(int i = IDELEMS(F)-1,j;i>strat->sbaEnterS+nrmon+1 ;i--)
+  {
+    //pWrite(F->m[i]);
+    if(F->m[i] != NULL && pNext(F->m[i]) == NULL)
+    {
+      poly mon = F->m[i];
+      for(j = i;j>strat->sbaEnterS+nrmon+1;j--)
+      {
+        F->m[j] = F->m[j-1];
+      }
+      F->m[j] = mon;
+      nrmon++;
+    }
+    //idPrint(F);
+  }
+  }
+    //printf("\nThis is the ideal after sorting\n");idPrint(F);getchar();
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+    strat->sigdrop = FALSE;
+  strat->nrsyzcrit = 0;
+  strat->nrrewcrit = 0;
+  #endif
 #if SBA_INTERRED_START
   F = kInterRed(F,NULL);
@@ -1888 +2178 @@
   BOOLEAN withT     = TRUE;
   strat->max_lower_index = 0;
-
   //initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
   initSbaCrit(strat); /*set Gebauer, honey, sugarCrit*/
@@ -1899 +2188 @@
   srmax = strat->sl;
   reduc = olddeg = lrmax = 0;
-
 #ifndef NO_BUCKETS
   if (!TEST_OPT_NOT_BUCKETS)
@@ -1922 +2210 @@
     kDebugPrint(strat);
   }
-
-
+  // We add the elements directly in S from the previous loop
+  if(rField_is_Ring(currRing) && strat->sbaEnterS >= 0)
+  {
+    for(int i = 0;i<strat->sbaEnterS;i++)
+    {
+      //Update: now the element is at the corect place
+      //i+1 because on the 0 position is the sigdrop element
+      enterT(strat->L[strat->Ll-(i)],strat);
+      strat->enterS(strat->L[strat->Ll-(i)], strat->sl+1, strat, strat->tl);
+    }
+    strat->Ll = strat->Ll - strat->sbaEnterS; 
+    strat->sbaEnterS = -1;
+  }
+  kTest_TS(strat);
 #ifdef KDEBUG
   //kDebugPrint(strat);
@@ -1930 +2230 @@
   while (strat->Ll >= 0)
   {
+    #if ADIDEBUG
+    printf("\n      ------------------------NEW LOOP\n");
+    printf("\nShdl = \n");
+    #if 0
+    idPrint(strat->Shdl);
+    #else
+    for(int ii = 0; ii<=strat->sl;ii++)
+    {
+      printf("\nS[%i]:  ",ii);p_Write(strat->S[ii],strat->tailRing);
+      printf("sig:   ");pWrite(strat->sig[ii]);
+    }
+    #endif
+    #if 0
+    for(int iii = 0; iii< strat->syzl; iii++)
+    {
+        printf("\nsyz[%i]:\n",iii);
+        p_Write(strat->syz[iii], currRing);
+    }
+    #endif
+    #if 0
+    for(int iii = 0; iii<= strat->tl; iii++)
+    {
+        printf("\nT[%i]:\n",iii);
+        p_Write(strat->T[iii].p, currRing);
+    }
+    #endif
+    printf("\n   list   L\n");
+    int iii;
+    #if 1
+    for(iii = 0; iii<= strat->Ll; iii++)
+    {
+        printf("\nL[%i]:\n",iii);
+        p_Write(strat->L[iii].p, currRing);
+        p_Write(strat->L[iii].p1, currRing);
+        p_Write(strat->L[iii].p2, currRing);
+        p_Write(strat->L[iii].sig, currRing);
+    }
+    #else
+    {
+        printf("L[%i]:",strat->Ll);
+        p_Write(strat->L[strat->Ll].p, strat->tailRing);
+        p_Write(strat->L[strat->Ll].p1, strat->tailRing);
+        p_Write(strat->L[strat->Ll].p2, strat->tailRing);
+        p_Write(strat->L[strat->Ll].sig, strat->tailRing);
+    }
+    #endif
+    //getchar();
+    #endif
     if (strat->Ll > lrmax) lrmax =strat->Ll;/*stat.*/
     #ifdef KDEBUG
@@ -1965 +2313 @@
       // initialize new syzygy rules for the next iteration step
       initSyzRules(strat);
-
     }
     /*********************************************************************
@@ -1974 +2321 @@
     strat->P = strat->L[strat->Ll];
     strat->Ll--;
+    
+    #ifdef HAVE_RINGS
+    if(rField_is_Ring(currRing))
+      strat->sbaEnterS = pGetComp(strat->P.sig) - 1;
+    #endif
+    
+    #if ADIDEBUG
+    printf("\n-------------------------\nThis is the current element P\n");
+    pWrite(strat->P.p);
+    pWrite(strat->P.p1);
+    pWrite(strat->P.p2);
+    pWrite(strat->P.sig);
+    #endif
     /* reduction of the element chosen from L */
-
-    if (!strat->rewCrit2(strat->P.sig, ~strat->P.sevSig, strat->P.GetLmCurrRing(), strat, strat->P.checked+1)) {
+    // We do not delete via RewCrit strong pairs or extended spolys over rings 
+    // these should have .lcm = NULL
+    if (strat->P.lcm == NULL || !strat->rewCrit2(strat->P.sig, ~strat->P.sevSig, strat->P.GetLmCurrRing(), strat, strat->P.checked+1)) {
       //#if 1
 #ifdef DEBUGF5
@@ -2025 +2386 @@
           strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
         // for input polys, prepare reduction
-        strat->P.PrepareRed(strat->use_buckets);
+        if(!rField_is_Ring(currRing))
+          strat->P.PrepareRed(strat->use_buckets);
       }
       if (strat->P.p == NULL && strat->P.t_p == NULL)
@@ -2063 +2425 @@
       red_result = 2;
     }
+    if(rField_is_Ring(currRing))
+    {
+      if(strat->P.sig!= NULL && !nGreaterZero(pGetCoeff(strat->P.sig)))
+      {
+        strat->P.p = pNeg(strat->P.p);
+        strat->P.sig = pNeg(strat->P.sig);
+      }
+      strat->P.pLength = pLength(strat->P.p);
+      if(strat->P.sig != NULL)
+        strat->P.sevSig = pGetShortExpVector(strat->P.sig);
+      if(strat->P.p != NULL)
+        strat->P.sev = pGetShortExpVector(strat->P.p);
+    }
+    #if ADIDEBUG
+    printf("\nAfter reduce (redresult=%i): \n",red_result);pWrite(strat->P.p);pWrite(strat->P.sig);
+    #endif
+    //sigdrop case
+    if(rField_is_Ring(currRing) && strat->sigdrop)
+    {
+      //First reduce it as much as one can
+      #if ADIDEBUG
+      printf("\nSigdrop in the reduce. Trying redring\n");
+      #endif
+      red_result = redRing(&strat->P,strat);
+      if(red_result == 0)
+      {
+        #if ADIDEBUG
+        printf("\nSigdrop cancelled since redRing reduced to 0\n");
+        #endif
+        strat->sigdrop = FALSE;
+        pDelete(&strat->P.sig);
+        strat->P.sig = NULL;
+      }
+      else
+      {
+        #if ADIDEBUG
+        printf("\nStill Sigdrop - redRing reduced to:\n");pWrite(strat->P.p);
+        #endif
+        strat->enterS(strat->P, 0, strat, strat->tl);
+        if (TEST_OPT_PROT)
+          PrintS("-");
+        break;
+      }
+    }
+    if(strat->blockred > strat->blockredmax)
+    {
+      #if ADIDEBUG
+      printf("\nToo many blocked reductions\n");
+      #endif
+      strat->sigdrop = TRUE;
+      break;
+    }
+    
     if (errorreported)  break;
 
@@ -2075 +2490 @@
     }
 #endif
+    if (TEST_OPT_PROT)
+    {
+      if(strat->P.p != NULL)
+        message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
+                &olddeg,&reduc,strat, red_result);
+      else
+        message((strat->honey ? strat->P.ecart : 0),
+                &olddeg,&reduc,strat, red_result);
+    }
 
     if (strat->overflow)
@@ -2080 +2504 @@
         if (!kStratChangeTailRing(strat)) { Werror("OVERFLOW.."); break;}
     }
-
     // reduction to non-zero new poly
     if (red_result == 1)
@@ -2106 +2529 @@
       // in the ring case we cannot expect LC(f) = 1,
       // therefore we call pContent instead of pNorm
+      #ifdef HAVE_RINGS
+      poly beforetailred;
+      if(rField_is_Ring(currRing))
+        beforetailred = pCopy(strat->P.sig);
+      #endif
 #if SBA_TAIL_RED
-      if (strat->sbaOrder != 2) {
-        if ((TEST_OPT_INTSTRATEGY) || (rField_is_Ring(currRing)))
-        {
-          strat->P.pCleardenom();
-          if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
+      if(rField_is_Ring(currRing))
+      {  
+        if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
+          strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
+      }
+      else
+      {
+        if (strat->sbaOrder != 2) {
+          if (TEST_OPT_INTSTRATEGY)
           {
-            strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
             strat->P.pCleardenom();
+            if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
+            {
+              strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
+              strat->P.pCleardenom();
+            }
           }
+          else
+          {
+            strat->P.pNorm();
+            if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
+              strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
+          }
+        }
+      }
+      // It may happen that we have lost the sig in redtailsba
+      // It cannot reduce to 0 since here we are doing just tail reduction. 
+      // Best case scenerio: remains the leading term
+      if(rField_is_Ring(currRing) && strat->sigdrop)     
+      {
+        #if ADIDEBUG
+        printf("\n Still sigdrop after redtailSba - it reduced to \n");pWrite(strat->P.p);
+        #endif
+        strat->enterS(strat->P, 0, strat, strat->tl);
+        break;
+      }
+#endif
+    if(rField_is_Ring(currRing))
+    {
+      if(strat->P.sig == NULL || pLtCmp(beforetailred,strat->P.sig) == 1)
+      {
+        #if ADIDEBUG
+        printf("\nSigDrop after TAILred\n");pWrite(beforetailred);pWrite(strat->P.sig);
+        #endif
+        strat->sigdrop = TRUE;
+        //Reduce it as much as you can
+        red_result = redRing(&strat->P,strat);
+        if(red_result == 0)
+        {
+          //It reduced to 0, cancel the sigdrop
+          #if ADIDEBUG
+          printf("\nReduced to 0 via redRing. Cancel sigdrop\n");
+          #endif
+          strat->sigdrop = FALSE;
+          p_Delete(&strat->P.sig,currRing);strat->P.sig = NULL;
         }
         else
         {
-          strat->P.pNorm();
-          if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
-            strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
-        }
-      }
-#endif
-
+          #if ADIDEBUG
+          printf("\nReduced to this via redRing.SIGDROP\n");pWrite(strat->P.p);
+          #endif
+          strat->enterS(strat->P, 0, strat, strat->tl);
+          break;
+        }
+      }
+      p_Delete(&beforetailred,currRing);
+      // strat->P.p = NULL may appear if we had  a sigdrop above and reduced to 0 via redRing
+      if(strat->P.p == NULL)
+        goto case_when_red_result_changed;
+    }
+    #if ADIDEBUG
+    printf("\nNach redTailSba: \n");
+    pWrite(strat->P.p);pWrite(strat->P.sig);
+    #endif
     // remove sigsafe label since it is no longer valid for the next element to
     // be reduced
@@ -2179 +2662 @@
       pWrite(strat->P.sig);
       */
+      if (rField_is_Ring(currRing))
+        superenterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
+      else
+        enterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
+      #if ADIDEBUG
+        printf("\nThis element is added to S\n");
+        p_Write(strat->P.p, strat->tailRing);p_Write(strat->P.p1, strat->tailRing);p_Write(strat->P.p2, strat->tailRing);pWrite(strat->P.sig);
+        getchar();
+        #endif
+      // posInS only depends on the leading term
+      
       #ifdef HAVE_RINGS
-      if (rField_is_Ring(currRing))
-        superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
-      else
+      if(rField_is_Ring(currRing) && strat->sigdrop)
+        break;
       #endif
-        enterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
-      // posInS only depends on the leading term
+      strat->P.sevSig = p_GetShortExpVector(strat->P.sig,currRing);
       strat->enterS(strat->P, pos, strat, strat->tl);
+      
       if(strat->sbaOrder != 1)
       {
@@ -2345 +2838 @@
     else
     {
+      case_when_red_result_changed:
       // adds signature of the zero reduction to
       // strat->syz. This is the leading term of
@@ -2354 +2848 @@
         zeroreductions++;
 #endif
-        int pos = posInSyz(strat, strat->P.sig);
-        enterSyz(strat->P, strat, pos);
-//#if 1
-#ifdef DEBUGF5
-        Print("ADDING STUFF TO SYZ :  ");
-        //pWrite(strat->P.p);
-        pWrite(strat->P.sig);
-#endif
+        #ifdef HAVE_RINGS
+        if(rField_is_Ring(currRing) && strat->P.p == NULL && strat->P.sig == NULL)
+        {
+          //Catch the case when p = 0, sig = 0
+        }
+        else
+        #endif
+        {
+          int pos = posInSyz(strat, strat->P.sig);
+          enterSyz(strat->P, strat, pos);
+  //#if 1
+  #ifdef DEBUGF5
+          Print("ADDING STUFF TO SYZ :  ");
+          //pWrite(strat->P.p);
+          pWrite(strat->P.sig);
+  #endif
+        }
       }
       if (strat->P.p1 == NULL && strat->minim > 0)
@@ -2374 +2877 @@
     kTest_TS(strat);
   }
+  #if 0
+  if(strat->sigdrop)
+    printf("\nSigDrop!\n");
+  else
+    printf("\nEnded with no SigDrop\n");
+  #endif
+// Clean strat->P for the next sba call
+#ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing) && strat->sigdrop)
+  {
+    //This is used to know how many elements can we directly add to S in the next run
+    if(strat->P.sig != NULL)
+      strat->sbaEnterS = pGetComp(strat->P.sig)-1;
+    //else we already set it at the beggining of the loop
+    #ifdef KDEBUG
+    memset(&(strat->P), 0, sizeof(strat->P));
+    #endif /* KDEBUG */
+  }
+#endif
 #ifdef KDEBUG
   if (TEST_OPT_DEBUG) messageSets(strat);
@@ -2397 +2919 @@
     }
   }
-
   /* complete reduction of the standard basis--------- */
   if (TEST_OPT_REDSB)
@@ -2421 +2942 @@
   size_syz = strat->syzl;
 #endif
-  exitSba(strat);
 //  if (TEST_OPT_WEIGHTM)
 //  {
@@ -2431 +2951 @@
 //    }
 //  }
-  if (TEST_OPT_PROT) messageStat(hilbcount,strat);
+  if (TEST_OPT_PROT) messageStatSBA(hilbcount,strat);
   if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
-
 #if SBA_PRINT_SIZE_G
   size_g_non_red  = IDELEMS(strat->Shdl);
 #endif
+  
+  idTest(strat->Shdl);
+  // I have to add the initial input polynomials which where not used (p1 and p2 = NULL)
+  #ifdef HAVE_RINGS
+  int k;
+  if(rField_is_Ring(currRing))
+  {
+    //for(k = strat->sl;k>=0;k--)
+    //  {printf("\nS[%i] = %p\n",k,strat->Shdl->m[k]);pWrite(strat->Shdl->m[k]);}
+    k = strat->Ll;
+    #if 1
+    // 1 - adds just the unused ones, 0 - adds everthing
+    for(;k>=0 && (strat->L[k].p1 != NULL || strat->L[k].p2 != NULL);k--)
+    {
+      //printf("\nDeleted k = %i, %p\n",k,strat->L[k].p);pWrite(strat->L[k].p);pWrite(strat->L[k].p1);pWrite(strat->L[k].p2);
+      deleteInL(strat->L,&strat->Ll,k,strat);
+    }
+    #endif
+    //for(int kk = strat->sl;kk>=0;kk--)
+    //  {printf("\nS[%i] = %p\n",kk,strat->Shdl->m[kk]);pWrite(strat->Shdl->m[kk]);}
+    //idPrint(strat->Shdl);
+  idTest(strat->Shdl);
+    //printf("\nk = %i\n",k);
+    for(;k>=0 && strat->L[k].p1 == NULL && strat->L[k].p2 == NULL;k--)
+    {
+      //printf("\nAdded k = %i\n",k);
+      strat->enterS(strat->L[k], strat->sl+1, strat, strat->tl);
+      //printf("\nThis elements was added from L on pos %i\n",strat->sl);pWrite(strat->S[strat->sl]);pWrite(strat->sig[strat->sl]);
+    }
+  }
+  // Find the "sigdrop element" and put the same signature as the previous one - do we really need this?? - now i put it on the 0 position - no more comparing needed
+  #if 0
+  if(strat->sigdrop && rField_is_Ring(currRing))
+  {
+    for(k=strat->sl;k>=0;k--)
+    {
+      printf("\nsig[%i] = ",i);pWrite(strat->sig[k]);
+      if(strat->sig[k] == NULL)
+        strat->sig[k] = pCopy(strat->sig[k-1]);
+    }
+  }
+  #endif
+  #endif
+  //Never do this - you will damage S
+  //idSkipZeroes(strat->Shdl);
+  //idPrint(strat->Shdl);
+  idTest(strat->Shdl);
+  
   if ((strat->sbaOrder == 1 || strat->sbaOrder == 3) && sRing!=currRingOld)
   {
@@ -2442 +3009 @@
     F0          = idrMoveR (F1, sRing, currRing);
     strat->Shdl = idrMoveR_NoSort (strat->Shdl, sRing, currRing);
+    rChangeCurrRing (sRing);
+    exitSba(strat);
+    rChangeCurrRing (currRingOld);
+    if(strat->tailRing == sRing)
+      strat->tailRing = currRing;
     rDelete (sRing);
   }
-  id_DelDiv(strat->Shdl, currRing);
+  #ifdef HAVE_RINGS
+  //if(nCoeff_is_Ring_Z(currRing->cf))
+  //  finalReduceByMon(strat);
+  if(rField_is_Ring(currRing) && !strat->sigdrop)
+  #endif
+    id_DelDiv(strat->Shdl, currRing);
   idSkipZeroes(strat->Shdl);
   idTest(strat->Shdl);
@@ -2707 +3284 @@
           }
           strat->initEcart(&h);
-          pos = strat->Ll+1;
+          if(rField_is_Ring(currRing))
+            pos = posInLF5CRing(strat->L, Ll_old+1,strat->Ll,&h,strat);
+          else
+            pos = strat->Ll+1;
           h.sev = pGetShortExpVector(h.p);
           enterL(&strat->L,&strat->Ll,&strat->Lmax,h,pos);
@@ -2774 +3354 @@
         strat->P.p2=p_Copy(strat->P.p, currRing, strat->tailRing);
       // for input polys, prepare reduction
-      strat->P.PrepareRed(strat->use_buckets);
+      if(!rField_is_Ring(currRing))
+        strat->P.PrepareRed(strat->use_buckets);
     }
 
@@ -2813 +3394 @@
       /* statistic */
       if (TEST_OPT_PROT) PrintS("s");
-
-      int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
-
+      int pos;
+      #if 1
+      if(!rField_is_Ring(currRing))
+        pos = posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
+      else
+        pos = posInSMonFirst(strat,strat->sl,strat->P.p,strat->P.ecart);
+      #else
+      pos = posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
+      #endif
       // reduce the tail and normalize poly
       // in the ring case we cannot expect LC(f) = 1,
@@ -2926 +3513 @@
   for (cc=strat->sl+1; cc<IDELEMS(strat->Shdl); ++cc)
     strat->Shdl->m[cc]  = NULL;
+  #if 0
+  printf("\nAfter f5c sorting\n");
+  for(int i=0;i<=strat->sl;i++)
+  pWrite(pHead(strat->S[i]));
+  getchar();
+  #endif
 //#if 1
 #if DEBUGF5

kernel/GBEngine/kutil.cc

@@ -13 +13 @@
 
 #define ADIDEBUG 0
+//All vs Just strategy over rings: 
+// 1 - Just 
+// 0 - All
+#define ALL_VS_JUST 0
+//Extended Spoly Strategy:
+// 0 - new gen sig
+// 1 - ann*old sig
+#define EXT_POLY_NEW 0
 
 #include <kernel/mod2.h>
@@ -554 +562 @@
      pGetShallowCopyDeleteProc(strat->tailRing, currRing) :
      NULL);
-
   for (j=0; j<=strat->tl; j++)
   {
@@ -575 +582 @@
         }
         else
-          pDelete(&p);
+        {
+          //pDelete(&p);
+          p = NULL;
+        }
         break;
       }
@@ -862 +872 @@
 {
   int i;
-
   // test P
   kFalseReturn(kTest_L(&(strat->P), strat->tailRing,
@@ -1221 +1230 @@
   assume(i<=strat->sl);
   assume(p!=NULL);
+  #if ALL_VS_JUST
+  //Over rings, if we construct the strong pair, do not add the spair
+  if(rField_is_Ring(currRing))
+  {
+    number s,t,d;
+    d = n_ExtGcd(pGetCoeff(p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
+
+    if (!nIsZero(s) && !nIsZero(t))  // evtl. durch divBy tests ersetzen
+    {
+      nDelete(&d);
+      nDelete(&s);
+      nDelete(&t);
+      return;
+    }
+    nDelete(&d);
+    nDelete(&s);
+    nDelete(&t);
+  }
+  #endif
   int      l,j,compare,compareCoeff;
   LObject  h;
@@ -1565 +1593 @@
   return TRUE;
 }
+
+BOOLEAN sbaCheckGcdPair (LObject* h,kStrategy strat)
+{
+  if(strat->sl < 0) return FALSE;
+  int i;
+  for(i=0;i<strat->sl;i++)
+  {
+    //Construct the gcd pair between h and S[i]
+    number d, s, t;
+    poly m1, m2, gcd;
+    d = n_ExtGcd(pGetCoeff(h->p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
+    if (nIsZero(s) || nIsZero(t))  // evtl. durch divBy tests ersetzen
+    {
+      nDelete(&d);
+      nDelete(&s);
+      nDelete(&t);
+    }
+    else
+    {
+      k_GetStrongLeadTerms(h->p, strat->S[i], currRing, m1, m2, gcd, strat->tailRing);
+      pSetCoeff0(m1, s);
+      pSetCoeff0(m2, t);
+      pSetCoeff0(gcd, d);
+      pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(h->p), m1, strat->tailRing), pp_Mult_mm(pNext(strat->S[i]), m2, strat->tailRing), strat->tailRing);
+      poly pSigMult = p_Copy(h->sig,currRing);
+      poly sSigMult = p_Copy(strat->sig[i],currRing);
+      pSigMult = p_Mult_mm(pSigMult,m1,currRing);
+      sSigMult = p_Mult_mm(sSigMult,m2,currRing);
+      p_LmDelete(m1, strat->tailRing);
+      p_LmDelete(m2, strat->tailRing);
+      poly pairsig = p_Add_q(pSigMult,sSigMult,currRing);
+      if(pairsig!= NULL && pLtCmp(pairsig,h->sig) == 0)
+      {
+        #if ADIDEBUG
+        printf("\nCan replace * (sig = *) with * (sig = *) since of * with sig *\n");
+        pWrite(h->p);pWrite(h->sig);pWrite(gcd);pWrite(pairsig);pWrite(strat->S[i]);pWrite(strat->sig[i]);
+        //getchar();
+        #endif
+        pDelete(&h->p);
+        h->p = gcd;
+        pDelete(&h->sig);
+        h->sig = pairsig;
+        pNext(h->sig) = NULL;
+        strat->initEcart(h);
+        h->sev = pGetShortExpVector(h->p);
+        h->sevSig = pGetShortExpVector(h->sig);
+        h->i_r1 = -1;h->i_r2 = -1;
+        if(h->lcm != NULL)
+        {
+          pDelete(&h->lcm);
+          h->lcm = NULL;
+        }
+        if (currRing!=strat->tailRing)
+          h->t_p = k_LmInit_currRing_2_tailRing(h->p, strat->tailRing);
+        return TRUE;
+      }
+      //Delete what you didn't use
+      pDelete(&gcd);
+      pDelete(&pairsig);
+    }
+  }
+  return FALSE;
+}
+
+BOOLEAN enterOneStrongPolySig (int i,poly p,poly sig,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR)
+{
+  number d, s, t;
+  assume(atR >= 0);
+  poly m1, m2, gcd,si;
+  assume(i<=strat->sl);
+  si = strat->S[i];
+  //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
+  {
+    nDelete(&d);
+    nDelete(&s);
+    nDelete(&t);
+    return FALSE;
+  }
+
+  k_GetStrongLeadTerms(p, si, currRing, m1, m2, gcd, strat->tailRing);
+  //p_Test(m1,strat->tailRing);
+  //p_Test(m2,strat->tailRing);
+  /*if(!enterTstrong)
+  {
+    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);
+  pSetCoeff0(gcd, d);
+  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)
+  {
+    // Print("t = %d; s = %d; d = %d\n", nInt(t), nInt(s), nInt(d));
+    PrintS("m1 = ");
+    p_wrp(m1, strat->tailRing);
+    PrintS(" ; m2 = ");
+    p_wrp(m2, strat->tailRing);
+    PrintS(" ; gcd = ");
+    wrp(gcd);
+    PrintS("\n--- create strong gcd poly: ");
+    Print("\n p: %d", i);
+    wrp(p);
+    Print("\n strat->S[%d]: ", i);
+    wrp(si);
+    PrintS(" ---> ");
+  }
+#endif
+
+  pNext(gcd) = p_Add_q(pp_Mult_mm(pNext(p), m1, strat->tailRing), pp_Mult_mm(pNext(si), m2, strat->tailRing), strat->tailRing);
+  
+#ifdef KDEBUG
+  if (TEST_OPT_DEBUG)
+  {
+    wrp(gcd);
+    PrintLn();
+  }
+#endif
+
+  //Check and set the signatures
+  poly pSigMult = p_Copy(sig,currRing);
+  poly sSigMult = p_Copy(strat->sig[i],currRing);
+  pSigMult = p_Mult_mm(pSigMult,m1,currRing);
+  sSigMult = p_Mult_mm(sSigMult,m2,currRing);
+  p_LmDelete(m1, strat->tailRing);
+  p_LmDelete(m2, strat->tailRing);
+  poly pairsig;
+  if(pLmCmp(pSigMult,sSigMult) == 0)
+  {
+    //Same lm, have to add them
+    pairsig = p_Add_q(pSigMult,sSigMult,currRing);
+    //This might be zero
+  }
+  else
+  {
+    //Set the sig to either pSigMult or sSigMult
+    if(pLtCmp(pSigMult,sSigMult)==1)
+    {
+      pairsig = pSigMult;
+      pDelete(&sSigMult);
+    }
+    else
+    {
+      pairsig = sSigMult;
+      pDelete(&pSigMult);
+    }
+  }
+
+  LObject h;
+  h.p = gcd;
+  h.tailRing = strat->tailRing;
+  h.sig = pairsig;
+  int posx;
+  h.pCleardenom();
+  strat->initEcart(&h);
+  h.sev = pGetShortExpVector(h.p);
+  h.i_r1 = -1;h.i_r2 = -1;
+  if (currRing!=strat->tailRing)
+    h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
+  if(h.sig == NULL)
+    {
+      #if ADIDEBUG
+      printf("\nPossible sigdrop in enterpairstrongSig (due to lost of sig)\n");
+      #endif
+      //sigdrop since we loose the signature
+      strat->sigdrop = TRUE;
+      //Try to reduce it as far as we can via redRing
+      int red_result = redRing(&h,strat);
+      #if ADIDEBUG
+      printf("\nAfter redRing reduce:\n");pWrite(h.p);
+      #endif
+      if(red_result == 0)
+      {
+        // Cancel the sigdrop
+        #if ADIDEBUG
+        printf("\nCancel the sigdrop. It reduced to 0\n");
+        #endif
+        p_Delete(&h.sig,currRing);h.sig = NULL;
+        strat->sigdrop = FALSE;
+        return FALSE;
+      }
+      else
+      {
+        #if ADIDEBUG
+        printf("\nSigdrop. end\n");
+        #endif
+        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
+        #if 1
+        strat->enterS(h,0,strat,strat->tl);
+        #endif
+        return FALSE;
+      }
+    }
+  if(!nGreaterZero(pGetCoeff(h.sig)))
+  {
+    h.sig = pNeg(h.sig);
+    h.p = pNeg(h.p);
+  }
+  #ifdef HAVE_RINGS
+  
+    if(rField_is_Ring(currRing) &&
+      pLtCmp(h.sig,sig) == -1
+      )
+    {
+      #if ADIDEBUG
+      printf("\nSigDrop in enteronestrongpolySig\n");
+      pWrite(h.sig);
+      pWrite(p);pWrite(sig);
+      pWrite(strat->S[i]);pWrite(strat->sig[i]);
+      #endif
+      strat->sigdrop = TRUE;
+      // Completely reduce it
+      int red_result = redRing(&h,strat);
+      if(red_result == 0)
+      {
+        // Reduced to 0
+        #if ADIDEBUG
+        printf("\nCancel the sigdrop after redRing (=0)\n");
+        #endif
+        strat->sigdrop = FALSE;
+        p_Delete(&h.sig,currRing);h.sig = NULL;
+        return FALSE;
+      }
+      else
+      {
+        #if ADIDEBUG
+        printf("\nAfter redRing still sigdrop:\n");pWrite(h.p);
+        #endif
+        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
+        // 0 - add just the original poly causing the sigdrop, 1 - add also this
+        #if 1
+        strat->enterS(h,0,strat, strat->tl+1);
+        #endif
+        return FALSE;
+      }
+    }
+    #endif
+  #if ADIDEBUG
+  printf("\nThis strong poly was added to L:\n");pWrite(h.p);pWrite(h.p1);pWrite(h.p2);pWrite(h.sig);
+  #endif
+  //Check for sigdrop
+  if(gcd != NULL && pLtCmp(sig,pairsig) > 0 && pLtCmp(strat->sig[i],pairsig) > 0)
+  {
+    #if ADIDEBUG
+    printf("\nSigDrop in strongpair\noriginals: ");pWrite(sig);pWrite(strat->sig[i]);
+    printf("\nnow: ");pWrite(pairsig);
+    #endif
+    strat->sigdrop = TRUE;
+    //Enter this element to S
+    strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
+    strat->enterS(h,strat->sl+1,strat,strat->tl+1);
+  }
+  #if 1
+  h.p1 = p;h.p2 = strat->S[i];
+  #endif
+  if (atR >= 0)
+  {
+    h.i_r2 = strat->S_2_R[i];
+    h.i_r1 = atR;
+  }
+  else
+  {
+    h.i_r1 = -1;
+    h.i_r2 = -1;
+  }
+  if (strat->Ll==-1)
+    posx =0;
+  else
+    posx = strat->posInLSba(strat->L,strat->Ll,&h,strat);
+  enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
+  return TRUE;
+}
 #endif
 
@@ -2073 +2389 @@
 #endif
 {
+  #if ADIDEBUG
+  printf("\nTrying to add p and S[%i]\n",i);
+  pWrite(p);pWrite(pSig);
+  pWrite(strat->S[i]);pWrite(strat->sig[i]);
+  #endif
+  #if ALL_VS_JUST
+  //Over rings, if we construct the strong pair, do not add the spair
+  if(rField_is_Ring(currRing))
+  {
+    number s,t,d;
+    d = n_ExtGcd(pGetCoeff(p), pGetCoeff(strat->S[i]), &s, &t, currRing->cf);
+
+    if (!nIsZero(s) && !nIsZero(t))  // evtl. durch divBy tests ersetzen
+    {
+      nDelete(&d);
+      nDelete(&s);
+      nDelete(&t);
+      return;
+    }
+    nDelete(&d);
+    nDelete(&s);
+    nDelete(&t);
+  }
+  #endif
   assume(i<=strat->sl);
-
   int      l;
   poly m1 = NULL,m2 = NULL; // we need the multipliers for the s-polynomial to compute
@@ -2099 +2438 @@
 
   // set coeffs of multipliers m1 and m2
-  pSetCoeff0(m1, nInit(1));
-  pSetCoeff0(m2, nInit(1));
-//#if 1
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+  {
+    number s = nCopy(pGetCoeff(strat->S[i]));
+    number t = nCopy(pGetCoeff(p));
+    pSetCoeff0(Lp.lcm, n_Lcm(s, t, currRing->cf));
+    ksCheckCoeff(&s, &t, currRing->cf);
+    pSetCoeff0(m1,s);
+    pSetCoeff0(m2,t);
+    #if ADIDEBUG
+    printf("\nIn Spoly: m1, m2 :\n");pWrite(m1);pWrite(m2);
+    #endif
+  }
+  else
+  #endif
+  {
+    pSetCoeff0(m1, nInit(1));
+    pSetCoeff0(m2, nInit(1));
+  }
 #ifdef DEBUGF5
   Print("P1  ");
@@ -2112 +2467 @@
   pWrite(m2);
 #endif
+  
   // get multiplied signatures for testing
-  pSigMult = currRing->p_Procs->pp_Mult_mm(pSigMult,m1,currRing);
+  pSigMult = pp_Mult_mm(pSigMult,m1,currRing);
   pSigMultNegSev = ~p_GetShortExpVector(pSigMult,currRing);
-  sSigMult = currRing->p_Procs->pp_Mult_mm(sSigMult,m2,currRing);
+  sSigMult = pp_Mult_mm(sSigMult,m2,currRing);
   sSigMultNegSev = ~p_GetShortExpVector(sSigMult,currRing);
-
 //#if 1
 #ifdef DEBUGF5
@@ -2126 +2481 @@
   Lp.checked  = 0;
 #endif
-  int sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
+  int sigCmp;
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+    sigCmp = p_LtCmpNoAbs(pSigMult,sSigMult,currRing);
+  else
+  #endif
+    sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
 //#if 1
 #if DEBUGF5
@@ -2133 +2494 @@
   pWrite(sSigMult);
 #endif
+  //In the ring case we already build the sig
+  if(rField_is_Ring(currRing))
+  {
+    //I have to test it not in absolute value
+    if(sigCmp == 0)
+    {
+      #if ADIDEBUG
+      printf("\nPossible sigdrop in enterpairSig (due to lost of sig)\n");
+      #endif
+      //sigdrop since we loose the signature
+      strat->sigdrop = TRUE;
+      //Try to reduce it as far as we can via redRing
+      if(rField_is_Ring(currRing))
+      {
+        poly p1 = p_Copy(p,currRing);
+        poly p2 = p_Copy(strat->S[i],currRing);
+        p1 = p_Mult_mm(p1,m1,currRing);
+        p2 = p_Mult_mm(p2,m2,currRing);
+        Lp.p = p_Sub(p1,p2,currRing);
+        if(Lp.p != NULL)
+          Lp.sev = p_GetShortExpVector(Lp.p,currRing);
+      }
+      int red_result = redRing(&Lp,strat);
+      #if ADIDEBUG
+      printf("\nAfter redRing reduce:\n");pWrite(Lp.p);
+      #endif
+      if(red_result == 0)
+      {
+        // Cancel the sigdrop
+        #if ADIDEBUG
+        printf("\nCancel the sigdrop. It reduced to 0\n");
+        #endif
+        p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
+        strat->sigdrop = FALSE;
+        return;
+      }
+      else
+      {
+        #if ADIDEBUG
+        printf("\nSigdrop. end\n");
+        #endif
+        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
+        #if 1
+        strat->enterS(Lp,0,strat,strat->tl);
+        #endif
+        return;
+      }
+    }
+    if(p_LmCmp(pSigMult,sSigMult,currRing) == 0)
+    {
+      //Same lm, have to substract
+      Lp.sig = p_Sub(pCopy(pSigMult),pCopy(sSigMult),currRing);
+    }
+    else
+    {
+      if(sigCmp == 1)
+      {
+        Lp.sig = pCopy(pSigMult);
+      }
+      if(sigCmp == -1)
+      {
+        Lp.sig = pNeg(pCopy(sSigMult));
+      }
+    }
+    Lp.sevSig = p_GetShortExpVector(Lp.sig,currRing);
+  }
+  
+  #if 0  
   if(sigCmp==0)
   {
@@ -2148 +2577 @@
     return;
   }
+  #endif
   // testing by syzCrit = F5 Criterion
   // testing by rewCrit1 = Rewritten Criterion
@@ -2153 +2583 @@
   if  ( strat->syzCrit(pSigMult,pSigMultNegSev,strat) ||
         strat->syzCrit(sSigMult,sSigMultNegSev,strat)
-        || strat->rewCrit1(sSigMult,sSigMultNegSev,Lp.lcm,strat,i+1)
+        // With this rewCrit activated i get a wrong deletion in sba_int_56.tst
+        //|| strat->rewCrit1(sSigMult,sSigMultNegSev,Lp.lcm,strat,i+1)
       )
   {
+    #if ADIDEBUG
+    printf("\nDELETED!\n");
+    #endif
     pDelete(&pSigMult);
     pDelete(&sSigMult);
@@ -2181 +2615 @@
   else
   {
-    #ifdef HAVE_PLURAL
-    if ( rIsPluralRing(currRing) )
-    {
-      if(pHasNotCF(p, strat->S[i]))
+    //Build p
+    if(rField_is_Ring(currRing))
+    {
+      poly p1 = p_Copy(p,currRing);
+      poly p2 = p_Copy(strat->S[i],currRing);
+      p1 = p_Mult_mm(p1,m1,currRing);
+      p2 = p_Mult_mm(p2,m2,currRing);
+      Lp.p = p_Sub(p1,p2,currRing);
+      if(Lp.p != NULL)
+        Lp.sev = p_GetShortExpVector(Lp.p,currRing);
+    }
+    else
+    {
+      #ifdef HAVE_PLURAL
+      if ( rIsPluralRing(currRing) )
       {
         if(ncRingType(currRing) == nc_lie)
@@ -2209 +2654 @@
       }
       else
-      {
-        Lp.p = // nc_CreateSpoly(strat->S[i],p,currRing);
-              nc_CreateShortSpoly(strat->S[i], p, currRing);
-
-        assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
-        pNext(Lp.p) = strat->tail; // !!!
-      }
-    }
-    else
-    #endif
-    {
-      assume(!rIsPluralRing(currRing));
-      Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
+      #endif
+      {
+        assume(!rIsPluralRing(currRing));
+        Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
+      }
     }
   }
   // store from which element this pair comes from for further tests
   //Lp.from = strat->sl+1;
-  if(sigCmp==currRing->OrdSgn)
-  {
-    // pSig > sSig
-    pDelete (&sSigMult);
-    Lp.sig    = pSigMult;
-    Lp.sevSig = ~pSigMultNegSev;
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+  {
+    //Put the sig to be > 0
+    if(!nGreaterZero(pGetCoeff(Lp.sig)))
+    {
+      Lp.sig = pNeg(Lp.sig);
+      Lp.p = pNeg(Lp.p);
+    }
   }
   else
-  {
-    // pSig < sSig
-    pDelete (&pSigMult);
-    Lp.sig    = sSigMult;
-    Lp.sevSig = ~sSigMultNegSev;
+  #endif
+  {
+    if(sigCmp==currRing->OrdSgn)
+    {
+      // pSig > sSig
+      pDelete (&sSigMult);
+      Lp.sig    = pSigMult;
+      Lp.sevSig = ~pSigMultNegSev;
+    }
+    else
+    {
+      // pSig < sSig
+      pDelete (&pSigMult);
+      Lp.sig    = sSigMult;
+      Lp.sevSig = ~sSigMultNegSev;
+    }
   }
   if (Lp.p == NULL)
@@ -2252 +2703 @@
     {
       pLmFree(Lp.lcm);
+      #if ADIDEBUG
+      printf("\nrewCrit3 deletes it!\n");
+      #endif
       pDelete(&Lp.sig);
       Lp.lcm=NULL;
@@ -2294 +2748 @@
         (!rIsPluralRing(currRing))
 //      ||  (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
+      #ifdef HAVE_RINGS 
+      && !rField_is_Ring(currRing)
+      #endif
        )
     {
@@ -2314 +2771 @@
     if (TEST_OPT_INTSTRATEGY)
     {
-      if (!rIsPluralRing(currRing))
+      if (!rIsPluralRing(currRing) 
+      #ifdef HAVE_RINGS 
+      && !rField_is_Ring(currRing)
+      #endif
+      )
         nDelete(&(Lp.p->coef));
     }
-
-    l = strat->posInLSba(strat->B,strat->Bl,&Lp,strat);
-    enterL(&strat->B,&strat->Bl,&strat->Bmax,Lp,l);
+    // Check for sigdrop
+    #ifdef HAVE_RINGS
+    if(rField_is_Ring(currRing) &&
+      pLtCmp(Lp.sig,pSig) == -1
+      )
+    {
+      #if ADIDEBUG
+      printf("\nSigDrop in enteronepairSig\n");pWrite(Lp.sig);
+      pWrite(p);pWrite(pSig);
+      pWrite(strat->S[i]);pWrite(strat->sig[i]);
+      #endif
+      strat->sigdrop = TRUE;
+      // Completely reduce it
+      int red_result = redRing(&Lp,strat);
+      if(red_result == 0)
+      {
+        // Reduced to 0
+        #if ADIDEBUG
+        printf("\nCancel the sigdrop after redRing (=0)\n");
+        #endif
+        strat->sigdrop = FALSE;
+        p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
+        return;
+      }
+      else
+      {
+        #if ADIDEBUG
+        printf("\nAfter redRing still sigdrop:\n");pWrite(Lp.p);
+        #endif
+        strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
+        // 0 - add just the original poly causing the sigdrop, 1 - add also this
+        #if 1
+        strat->enterS(Lp,0,strat, strat->tl+1);
+        #endif
+        return;
+      }
+    }
+    #endif
+    #if ADIDEBUG
+    printf("\nThis spair was added to B:\n");
+    pWrite(Lp.p);
+    pWrite(Lp.p1);
+    pWrite(Lp.p2);
+    pWrite(Lp.sig);
+    #endif
+    l = strat->posInLSba(strat->L,strat->Ll,&Lp,strat);
+    enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,l);
   }
 }
@@ -3101 +3606 @@
       if ((isFromQ)&&(strat->fromQ!=NULL))
       {
-        for (j=0; j<=k; j++)
+        for (j=0; j<=k && !strat->sigdrop; j++)
         {
           if (!strat->fromQ[j])
@@ -3114 +3619 @@
       {
         new_pair=TRUE;
-        for (j=0; j<=k; j++)
+        for (j=0; j<=k && !strat->sigdrop; j++)
         {
           enterOnePairSig(j,h,hSig,hFrom,ecart,isFromQ,strat, atR);
@@ -3123 +3628 @@
     else
     {
-      for (j=0; j<=k; j++)
+      for (j=0; j<=k && !strat->sigdrop; j++)
       {
         if ((pGetComp(h)==pGetComp(strat->S[j]))
@@ -3135 +3640 @@
     }
 
+#if 0
     if (new_pair)
     {
@@ -3144 +3650 @@
       strat->chainCrit(h,ecart,strat);
     }
+#endif
   }
 }
@@ -3759 +4266 @@
     }
   }
-/*
-ring r=256,(x,y,z),dp;
-ideal I=12xz-133y, 2xy-z;
-*/
+}
+
+void initenterstrongPairsSig (poly h,poly hSig, int hFrom, int k,int ecart,int isFromQ,kStrategy strat, int atR = -1)
+{
+  const int iCompH = pGetComp(h);
+  if (!nIsOne(pGetCoeff(h)))
+  {
+    int j;
+
+    for (j=0; j<=k && !strat->sigdrop; j++)
+    {
+      // Print("j:%d, Ll:%d\n",j,strat->Ll);
+//      if (((unsigned long) pGetCoeff(h) % (unsigned long) pGetCoeff(strat->S[j]) != 0) &&
+//         ((unsigned long) pGetCoeff(strat->S[j]) % (unsigned long) pGetCoeff(h) != 0))
+      if (((iCompH == pGetComp(strat->S[j]))
+      || (0 == pGetComp(strat->S[j])))
+      && ((iCompH<=strat->syzComp)||(strat->syzComp==0)))
+      {
+        enterOneStrongPolySig(j,h,hSig,ecart,isFromQ,strat, atR);
+      }
+    }
+  }
 }
 #endif
@@ -3822 +4347 @@
       p = p_LmFreeAndNext(p, strat->tailRing);
       pNext(tmp) = p;
-      LObject h;
-      h.Init();
-      h.p = tmp;
-      h.tailRing = strat->tailRing;
+      LObject Lp;
+      Lp.Init();
+      Lp.p = tmp;
+      Lp.tailRing = strat->tailRing;
       int posx;
-      if (h.p!=NULL)
-      {
-        if (TEST_OPT_INTSTRATEGY)
-        {
-          //pContent(h.p);
-          h.pCleardenom(); // also does a pContent
-        }
-        else
-        {
-          h.pNorm();
-        }
-        strat->initEcart(&h);
+      if (Lp.p!=NULL)
+      {
+        strat->initEcart(&Lp);
         if (strat->Ll==-1)
           posx =0;
         else
-          posx = strat->posInL(strat->L,strat->Ll,&h,strat);
-        h.sev = pGetShortExpVector(h.p);
+          posx = strat->posInL(strat->L,strat->Ll,&Lp,strat);
+        Lp.sev = pGetShortExpVector(Lp.p);
         if (strat->tailRing != currRing)
         {
-          h.t_p = k_LmInit_currRing_2_tailRing(h.p, strat->tailRing);
+          Lp.t_p = k_LmInit_currRing_2_tailRing(Lp.p, strat->tailRing);
         }
 #ifdef KDEBUG
@@ -3855 +4371 @@
         }
 #endif
+        enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
+      }
+    }
+  }
+  nDelete(&gcd);
+}
+
+void enterExtendedSpolySig(poly h,poly hSig,kStrategy strat)
+{
+  if (nIsOne(pGetCoeff(h))) return;
+  number gcd;
+  bool go = false;
+  if (n_DivBy((number) 0, pGetCoeff(h), currRing->cf))
+  {
+    gcd = n_Ann(pGetCoeff(h),currRing->cf);
+    go = true;
+  }
+  else
+    gcd = n_Gcd((number) 0, pGetCoeff(h), strat->tailRing->cf);
+  if (go || !nIsOne(gcd))
+  {
+    poly p = h->next;
+    if (!go)
+    {
+      number tmp = gcd;
+      gcd = n_Ann(gcd,currRing->cf);
+      nDelete(&tmp);
+    }
+    p_Test(p,strat->tailRing);
+    p = pp_Mult_nn(p, gcd, strat->tailRing);
+
+    if (p != NULL)
+    {
+      if (TEST_OPT_PROT)
+      {
+        PrintS("Z");
+      }
+#ifdef KDEBUG
+      if (TEST_OPT_DEBUG)
+      {
+        PrintS("--- create zero spoly: ");
+        p_wrp(h,currRing,strat->tailRing);
+        PrintS(" ---> ");
+      }
+#endif
+      poly tmp = pInit();
+      pSetCoeff0(tmp, pGetCoeff(p));
+      for (int i = 1; i <= rVar(currRing); i++)
+      {
+        pSetExp(tmp, i, p_GetExp(p, i, strat->tailRing));
+      }
+      if (rRing_has_Comp(currRing) && rRing_has_Comp(strat->tailRing))
+      {
+        p_SetComp(tmp, p_GetComp(p, strat->tailRing), currRing);
+      }
+      p_Setm(tmp, currRing);
+      p = p_LmFreeAndNext(p, strat->tailRing);
+      pNext(tmp) = p;
+      LObject Lp;
+      Lp.Init();
+      Lp.p = tmp;
+      //printf("\nOld\n");pWrite(h);pWrite(hSig);
+      #if EXT_POLY_NEW
+      Lp.sig = pp_Mult_nn(hSig, gcd, currRing);
+      if(Lp.sig == NULL || nIsZero(pGetCoeff(Lp.sig)))
+      {
+        #if ADIDEBUG
+        printf("\nSigdrop in enterextended spoly\n");pWrite(h);pWrite(hSig);
+        #endif
+        strat->sigdrop = TRUE;
+        //Try to reduce it as far as we can via redRing
+        int red_result = redRing(&Lp,strat);
+        #if ADIDEBUG
+        printf("\nAfter redRing reduce:\n");pWrite(Lp.p);
+        #endif
+        if(red_result == 0)
+        {
+          // Cancel the sigdrop
+          #if ADIDEBUG
+          printf("\nCancel the sigdrop. It reduced to 0\n");
+          #endif
+          p_Delete(&Lp.sig,currRing);Lp.sig = NULL;
+          strat->sigdrop = FALSE;
+          return;
+        }
+        else
+        {
+          #if ADIDEBUG
+          printf("\nSigdrop. end\n");
+          #endif
+          strat->enterS(strat->P,strat->sl+1,strat, strat->tl+1);
+          #if 1
+          strat->enterS(Lp,0,strat,strat->tl);
+          #endif
+          return;
+        }
+        
+      }
+      #else
+      Lp.sig = pOne();
+      if(strat->Ll >= 0)
+        p_SetComp(Lp.sig,pGetComp(strat->L[0].sig)+1,currRing);
+      else
+        p_SetComp(Lp.sig,pGetComp(hSig)+1,currRing);
+      #endif
+      Lp.tailRing = strat->tailRing;
+      int posx;
+      if (Lp.p!=NULL)
+      {
+        strat->initEcart(&Lp);
+        if (strat->Ll==-1)
+          posx =0;
+        else
+          posx = strat->posInLSba(strat->L,strat->Ll,&Lp,strat);
+        Lp.sev = pGetShortExpVector(Lp.p);
+        if (strat->tailRing != currRing)
+        {
+          Lp.t_p = k_LmInit_currRing_2_tailRing(Lp.p, strat->tailRing);
+        }
+#ifdef KDEBUG
+        if (TEST_OPT_DEBUG)
+        {
+          p_wrp(tmp,currRing,strat->tailRing);
+          PrintLn();
+        }
+#endif
         enterL(&strat->L,&strat->Ll,&strat->Lmax,h,posx);
-      }
-    }
+        enterL(&strat->L,&strat->Ll,&strat->Lmax,Lp,posx);
+      }
+    }
+    nDelete(&gcd);
   }
   nDelete(&gcd);
@@ -3897 +4541 @@
   initenterpairs(h, k, ecart, 0, strat, atR);
   initenterstrongPairs(h, k, ecart, 0, strat, atR);
+  clearSbatch(h, k, pos, strat);
+}
+
+void superenterpairsSig (poly h,poly hSig,int hFrom,int k,int ecart,int pos,kStrategy strat, int atR)
+{
+  assume (rField_is_Ring_Z(currRing));
+  // enter also zero divisor * poly, if this is non zero and of smaller degree
+  #if ADIDEBUG
+  printf("\n      Trying to add extended spolys\n");
+  #endif
+  if (!(rField_is_Domain(currRing))) enterExtendedSpolySig(h, hSig, strat);
+  if(strat->sigdrop) return;
+  #if ADIDEBUG
+  printf("\n      Trying to add spolys\n");
+  #endif
+  initenterpairsSig(h, hSig, hFrom, k, ecart, 0, strat, atR);
+  if(strat->sigdrop) return;
+  #if ADIDEBUG
+  printf("\n      Trying to add gcd-polys\n");
+  #endif
+  initenterstrongPairsSig(h, hSig, hFrom,k, ecart, 0, strat, atR);
+  if(strat->sigdrop) return;
   clearSbatch(h, k, pos, strat);
 }
@@ -4176 +4842 @@
       }
     }
+  }
+}
+
+
+// sorts by degree and pLtCmp
+// but puts pure monomials at the beginning
+int posInSMonFirst (const kStrategy strat, const int length,const poly p,
+            const int ecart_p)
+{
+  if (length<0) return 0;
+  polyset set=strat->S;
+  if(pNext(p) == NULL)
+  {
+    int mon = 0;
+    for(int i = 0;i<=length;i++)
+    {
+      if(set[i] != NULL && pNext(set[i]) == NULL)
+        mon++;
+    }
+    int o = p_Deg(p,currRing);
+    int op = p_Deg(set[mon],currRing);
+    
+    if ((op < o)
+    || ((op == o) && (pLtCmp(set[mon],p) == -1)))
+      return length+1;
+    int i;
+    int an = 0;
+    int en= mon;
+    loop
+    {
+      if (an >= en-1)
+      {
+        op = p_Deg(set[an],currRing);
+        if ((op < o)
+        || ((op == o) && (pLtCmp(set[an],p) == -1)))
+          return en;
+        return an;
+      }
+      i=(an+en) / 2;
+      op = p_Deg(set[i],currRing);
+      if ((op < o)
+      || ((op == o) && (pLtCmp(set[i],p) == -1)))
+        an=i;
+      else
+        en=i;
+    }
+  }
+  if(pNext(p) != NULL)
+  {
+    int o = p_Deg(p,currRing);
+    int op = p_Deg(set[length],currRing);
+    
+    if ((op < o)
+    || ((op == o) && (pLtCmp(set[length],p) == -1)))
+      return length+1;
+    int i;
+    int an = 0;
+    for(i=0;i<=length;i++)
+      if(set[i] != NULL && pNext(set[i]) == NULL)
+        an++;
+    int en= length;
+    loop
+    {
+      if (an >= en-1)
+      {
+        op = p_Deg(set[an],currRing);
+        if ((op < o)
+        || ((op == o) && (pLtCmp(set[an],p) == -1)))
+          return en;
+        return an;
+      }
+      i=(an+en) / 2;
+      op = p_Deg(set[i],currRing);
+      if ((op < o)
+      || ((op == o) && (pLtCmp(set[i],p) == -1)))
+        an=i;
+      else
+        en=i;
+    }
+  }
+}
+
+// sorts by degree and pLtCmp in the block between start,end;
+// but puts pure monomials at the beginning
+int posInIdealMonFirst (const ideal F, const poly p,int start,int end)
+{
+  if(end < 0 || end >= IDELEMS(F))
+    end = IDELEMS(F);
+  if (end<0) return 0;
+  if(pNext(p) == NULL) return start;
+  polyset set=F->m;
+  int o = p_Deg(p,currRing);
+  int op;
+  int i;
+  int an = start;
+  for(i=start;i<end;i++)
+    if(set[i] != NULL && pNext(set[i]) == NULL)
+      an++;
+  if(an == end-1)
+    return end;
+  int en= end;
+  loop
+  {
+    if(an>=en)
+      return en;
+    if (an == en-1)
+    {
+      op = p_Deg(set[an],currRing);
+      if ((op < o)
+      || ((op == o) && (pLtCmp(set[an],p) == -1)))
+        return en;
+      return an;
+    }
+    i=(an+en) / 2;
+    op = p_Deg(set[i],currRing);
+    if ((op < o)
+    || ((op == o) && (pLtCmp(set[i],p) == -1)))
+      an=i;
+    else
+      en=i;
   }
 }
@@ -5053 +5839 @@
                LObject* p,const kStrategy /*strat*/)
 {
-if (length<0) return 0;
-if (pLmCmp(set[length].sig,p->sig)== currRing->OrdSgn)
-  return length+1;
-
-int i;
-int an = 0;
-int en= length;
-loop
-{
-  if (an >= en-1)
-  {
-    if (pLmCmp(set[an].sig,p->sig) == currRing->OrdSgn) return en;
-    return an;
-  }
-  i=(an+en) / 2;
-  if (pLmCmp(set[i].sig,p->sig) == currRing->OrdSgn) an=i;
-  else                                      en=i;
-  /*aend. fuer lazy == in !=- machen */
-}
+  if (length<0) return 0;
+  if (pLtCmp(set[length].sig,p->sig)== currRing->OrdSgn)
+    return length+1;
+
+  int i;
+  int an = 0;
+  int en= length;
+  loop
+  {
+    if (an >= en-1)
+    {
+      if (pLtCmp(set[an].sig,p->sig) == currRing->OrdSgn) return en;
+      return an;
+    }
+    i=(an+en) / 2;
+    if (pLtCmp(set[i].sig,p->sig) == currRing->OrdSgn) an=i;
+    else                                      en=i;
+    /*aend. fuer lazy == in !=- machen */
+  }
+}
+//sorts the pair list in this order: pLtCmp on the sigs, FDeg, pLtCmp on the polys
+int posInLSigRing (const LSet set, const int length,
+               LObject* p,const kStrategy /*strat*/)
+{
+  assume(currRing->OrdSgn == 1 && rField_is_Ring(currRing));
+  if (length<0) return 0;
+  if (pLtCmp(set[length].sig,p->sig)== 1)
+    return length+1;
+
+  int an,en,i;
+  an = 0;
+  en = length+1;
+  int cmp;
+  loop
+  {
+    if (an >= en-1)
+    {
+      if(an == en)
+        return en;
+      cmp = pLtCmp(set[an].sig,p->sig);
+      if (cmp == 1)
+        return en;
+      if (cmp == -1)
+        return an;
+      if (cmp == 0)
+      {
+         if (set[an].FDeg > p->FDeg)
+          return en;
+         if (set[an].FDeg < p->FDeg)
+          return an;
+         if (set[an].FDeg == p->FDeg)
+         {
+            cmp = pLtCmp(set[an].p,p->p);
+            if(cmp == 1)
+              return en;
+            else
+              return an;
+         }
+      }
+    }
+    i=(an+en) / 2;
+    cmp = pLtCmp(set[i].sig,p->sig);
+    if (cmp == 1)
+      an = i;
+    if (cmp == -1)
+      en = i;
+    if (cmp == 0)
+    {
+       if (set[i].FDeg > p->FDeg)
+        an = i;
+       if (set[i].FDeg < p->FDeg)
+        en = i;
+       if (set[i].FDeg == p->FDeg)
+       {
+          cmp = pLtCmp(set[i].p,p->p);
+          if(cmp == 1)
+            an = i;
+          else
+            en = i;
+       }
+    }
+  }
 }
 
@@ -5150 +5999 @@
 {
   if (strat->syzl==0) return 0;
-  if (pLmCmp(strat->syz[strat->syzl-1],sig) != currRing->OrdSgn)
+  if (pLtCmp(strat->syz[strat->syzl-1],sig) != currRing->OrdSgn)
     return strat->syzl;
   int i;
@@ -5159 +6008 @@
     if (an >= en-1)
     {
-      if (pLmCmp(strat->syz[an],sig) != currRing->OrdSgn) return en;
+      if (pLtCmp(strat->syz[an],sig) != currRing->OrdSgn) return en;
       return an;
     }
     i=(an+en) / 2;
-    if (pLmCmp(strat->syz[i],sig) != currRing->OrdSgn) an=i;
+    if (pLtCmp(strat->syz[i],sig) != currRing->OrdSgn) an=i;
     else                                      en=i;
     /*aend. fuer lazy == in !=- machen */
@@ -5242 +6091 @@
   int i;
   int an = 0;
+  int en= length;
+  loop
+  {
+    if (an >= en-1)
+    {
+      op = set[an].GetpFDeg();
+      if ((op > o)
+      || ((op == o) && (pLtCmpOrdSgnDiffM(set[an].p,p->p))))
+        return en;
+      return an;
+    }
+    i=(an+en) / 2;
+    op = set[i].GetpFDeg();
+    if ((op > o)
+    || ((op == o) && (pLtCmpOrdSgnDiffM(set[i].p,p->p))))
+      an=i;
+    else
+      en=i;
+  }
+}
+
+int posInLF5CRing (const LSet set, int start,const int length,
+              LObject* p,const kStrategy strat)
+{
+  if (length<0) return 0;
+  if(start == (length +1)) return (length+1);
+  int o = p->GetpFDeg();
+  int op = set[length].GetpFDeg();
+
+  if ((op > o)
+  || ((op == o) && (pLtCmpOrdSgnDiffM(set[length].p,p->p))))
+    return length+1;
+  int i;
+  int an = start;
   int en= length;
   loop
@@ -5890 +6773 @@
     pWrite(pHead(strat->syz[k]));
 #endif
-    if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing))
+    if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
+    #ifdef HAVE_RINGS
+    && (!rField_is_Ring(currRing) || 
+    (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1))
+    #endif
+    )
     {
 //#if 1
@@ -5896 +6784 @@
       PrintS("DELETE!\n");
 #endif
+      #if ADIDEBUG
+      printf("\nsyzCrit:\n");pWrite(strat->syz[k]);pWrite(sig);
+      #endif
+      strat->nrsyzcrit++;
       //printf("- T -\n\n");
       return TRUE;
@@ -5939 +6831 @@
       pWrite(pHead(strat->syz[k]));
 #endif
-      if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing))
+      if (p_LmShortDivisibleBy(strat->syz[k], strat->sevSyz[k], sig, not_sevSig, currRing)
+      #ifdef HAVE_RINGS
+      && (!rField_is_Ring(currRing) || 
+      (n_DivBy(pGetCoeff(sig), pGetCoeff(strat->syz[k]),currRing) && pLtCmp(sig,strat->syz[k]) == 1))
+    #endif      
+      )
+      {
+        #if ADIDEBUG
+        printf("\nsyzCrit:\n");pWrite(strat->syz[k]);pWrite(sig);
+        #endif
+        strat->nrsyzcrit++;
         return TRUE;
+      }
     }
     return FALSE;
@@ -5952 +6855 @@
 {
   //printf("Faugere Rewritten Criterion\n");
+  if(rField_is_Ring(currRing))
+    return FALSE;
 //#if 1
 #ifdef DEBUGF5
@@ -5965 +6870 @@
     pWrite(pHead(strat->S[k]));
 #endif
-    if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing))
+    if (p_LmShortDivisibleBy(strat->sig[k], strat->sevSig[k], sig, not_sevSig, currRing)
+    #ifdef HAVE_RINGS
+    && (!rField_is_Ring(currRing) || (n_DivBy(pGetCoeff(sig),pGetCoeff(strat->sig[k]),currRing)  && pLmCmp(sig,strat->sig[k]) == 1 ))
+    #endif
+    )
     {
 //#if 1
@@ -5971 +6880 @@
       PrintS("DELETE!\n");
 #endif
+      #if ADIDEBUG
+      printf("\nFaugere RewCrit: * divisible by *\n");pWrite(sig);pWrite(strat->sig[k]);
+      #endif
+      strat->nrrewcrit++;
       return TRUE;
     }
@@ -6007 +6920 @@
 BOOLEAN arriRewCriterion(poly /*sig*/, unsigned long /*not_sevSig*/, poly /*lm*/, kStrategy strat, int start=0)
 {
+  return FALSE;
   poly p1 = pOne();
   poly p2 = pOne();
   for (int ii=strat->sl; ii>start; ii--)
   {
-    if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing))
+    if (p_LmShortDivisibleBy(strat->sig[ii], strat->sevSig[ii], strat->P.sig, ~strat->P.sevSig, currRing)
+    #ifdef HAVE_RINGS
+    && (!(rField_is_Ring(currRing)) || n_DivBy(pGetCoeff(strat->P.sig),pGetCoeff(strat->sig[ii]),currRing))
+    #endif
+    )
     {
       p_ExpVectorSum(p1,strat->P.sig,strat->S[ii],currRing);
       p_ExpVectorSum(p2,strat->sig[ii],strat->P.p,currRing);
+      #ifdef HAVE_RINGS
+      if((rField_is_Ring(currRing) && !(pLtCmp(p1,p2) == 1))
+        || (!rField_is_Ring(currRing) && !(pLmCmp(p1,p2) == 1)))
+      #else
       if (!(pLmCmp(p1,p2) == 1))
-      {
+      #endif
+      {
+        #if ADIDEBUG
+        printf("\narriRewCrit deleted: sig, P.sig\n");
+        
+        #endif
         pDelete(&p1);
         pDelete(&p2);
@@ -6030 +6957 @@
 BOOLEAN arriRewCriterionPre(poly sig, unsigned long not_sevSig, poly lm, kStrategy strat, int /*start=0*/)
 {
+  #ifdef HAVE_RINGS
+  //Over Rings, there are still some changes to do: considering coeffs
+  if(rField_is_Ring(currRing))
+    return FALSE;
+  #endif
   int found = -1;
-  for (int i=strat->Bl; i>-1; i--)
-  {
-    if (pLmEqual(strat->B[i].sig,sig))
+  for (int i=strat->Bl; i>-1; i--) {
+    if (pLmEqual(strat->B[i].sig,sig)
+    #ifdef HAVE_RINGS
+    && (rField_is_Ring(currRing) && n_Equal(pGetCoeff(strat->B[i].sig),pGetCoeff(sig),currRing))
+    #endif
+    ) 
     {
       found = i;
@@ -6565 +7500 @@
   //Print("%d/%d polynomials in set L (for lazy alg.)",lrmax+1,strat->Lmax);
   Print("product criterion:%d chain criterion:%d\n",strat->cp,strat->c3);
+  if (hilbcount!=0) Print("hilbert series criterion:%d\n",hilbcount);
+  /* in usual case strat->cv is 0, it gets changed only in shift routines */
+  if (strat->cv!=0) Print("shift V criterion:%d\n",strat->cv);
+  /*mflush();*/
+}
+
+void messageStatSBA (int hilbcount,kStrategy strat)
+{
+  //PrintS("\nUsage/Allocation of temporary storage:\n");
+  //Print("%d/%d polynomials in standard base\n",srmax,IDELEMS(Shdl));
+  //Print("%d/%d polynomials in set L (for lazy alg.)",lrmax+1,strat->Lmax);
+  Print("syz criterion:%d rew criterion:%d\n",strat->nrsyzcrit,strat->nrrewcrit);
+  //Print("product criterion:%d chain criterion:%d\n",strat->cp,strat->c3);
   if (hilbcount!=0) Print("hilbert series criterion:%d\n",hilbcount);
   /* in usual case strat->cv is 0, it gets changed only in shift routines */
@@ -6974 +7922 @@
   if( strat->S[0] )
   {
-    if( strat->S[1] )
+    if( strat->S[1] && !rField_is_Ring(currRing))
     {
       omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
@@ -7041 +7989 @@
         {
           Q.sig          = pOne();
+          #ifdef HAVE_RINGS
+          if(rField_is_Ring(currRing))
+            p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
+          #endif
           p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
           p_SetCompP (Q.sig, comp, currRing);
           poly q          = p_One(currRing);
+          #ifdef HAVE_RINGS
+          if(rField_is_Ring(currRing))
+            p_SetCoeff(q,nCopy(p_GetCoeff(strat->S[i],currRing)),currRing);
+          #endif
           p_ExpVectorCopy(q,strat->S[i],currRing);
           q               = p_Neg (q, currRing);
@@ -7081 +8037 @@
     {
       Q.sig          = pOne();
+      #ifdef HAVE_RINGS
+      if(rField_is_Ring(currRing))
+        p_SetCoeff(Q.sig,nCopy(p_GetCoeff(strat->S[k],currRing)),currRing);
+      #endif
       p_ExpVectorCopy(Q.sig,strat->S[k],currRing);
       p_SetCompP (Q.sig, comp, currRing);
       poly q          = p_One(currRing);
+      #ifdef HAVE_RINGS
+      if(rField_is_Ring(currRing))
+        p_SetCoeff(q,nCopy(p_GetCoeff(strat->L[strat->Ll].p,currRing)),currRing);
+      #endif
       p_ExpVectorCopy(q,strat->L[strat->Ll].p,currRing);
       q               = p_Neg (q, currRing);
@@ -7959 +8923 @@
   // appear due to the fact that the critical pairs are already sorted
   // by increasing signature.
+  // True. However, in the case of integers we need to put the element
+  // that caused the signature drop on the first position
   if (atS <= strat->sl)
   {
@@ -7964 +8930 @@
     memmove(&(strat->S[atS+1]), &(strat->S[atS]),
             (strat->sl - atS + 1)*sizeof(poly));
+    memmove(&(strat->sig[atS+1]), &(strat->sig[atS]),
+            (strat->sl - atS + 1)*sizeof(poly));
+    memmove(&(strat->sevSig[atS+1]), &(strat->sevSig[atS]),
+            (strat->sl - atS + 1)*sizeof(unsigned long));
     memmove(&(strat->ecartS[atS+1]), &(strat->ecartS[atS]),
             (strat->sl - atS + 1)*sizeof(int));
@@ -7983 +8953 @@
       strat->sevS[i] = strat->sevS[i-1];
       strat->S_2_R[i] = strat->S_2_R[i-1];
+      strat->sig[i] = strat->sig[i-1];
+      strat->sevSig[i] = strat->sevSig[i-1];
     }
     if (strat->lenS!=NULL)
@@ -8107 +9079 @@
   #if ADIDEBUG
   printf("\nenterT: add in position %i\n",atT);
-  pWrite(p.p);
+  pWrite(p.p);pWrite(p.sig);
   #endif
   //printf("\nenterT: neue hingefÌgt: lÀnge = %i, ecart = %i\n",p.length,p.ecart);
@@ -8242 +9214 @@
 void enterSyz(LObject &p, kStrategy strat, int atT)
 {
+  #if ADIDEBUG
+  printf("\n  Entersyz:\n");pWrite(p.sig);
+  #endif
   int i;
   strat->newt = TRUE;
@@ -8271 +9246 @@
   //i = strat->syzl;
   i = atT;
+  //Makes sure the syz saves just the signature
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+    pNext(p.sig) = NULL;
+  #endif
   strat->syz[atT] = p.sig;
   strat->sevSyz[atT] = p.sevSig;
@@ -8282 +9262 @@
   while (cc>-1)
   {
+    //printf("\nCheck if syz is div by L\n");pWrite(strat->syz[atT]);pWrite(strat->L[cc].sig);
+    //printf("\npLmShDivBy(syz,L) = %i\nn_DivBy(L,syz) = %i\n pLtCmp(L,syz) = %i",p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],strat->L[cc].sig, ~strat->L[cc].sevSig, currRing), n_DivBy(pGetCoeff(strat->L[cc].sig),pGetCoeff(strat->syz[atT]),currRing), pLtCmp(strat->L[cc].sig,strat->syz[atT])==1);
     if (p_LmShortDivisibleBy( strat->syz[atT], strat->sevSyz[atT],
-                              strat->L[cc].sig, ~strat->L[cc].sevSig, currRing))
-    {
+                              strat->L[cc].sig, ~strat->L[cc].sevSig, currRing)
+                              #ifdef HAVE_RINGS
+                              &&(rField_is_Ring(currRing)) 
+                              && n_DivBy(pGetCoeff(strat->L[cc].sig),pGetCoeff(strat->syz[atT]),currRing) && (pLtCmp(strat->L[cc].sig,strat->syz[atT])==1)
+                              #endif
+                              )
+    {
+      //printf("\nYES!\n");
+      #if ADIDEBUG
+      printf("\n syzCrit deleted!\n");pWrite(strat->L[cc].p);pWrite(strat->L[cc].sig);
+      #endif
       deleteInL(strat->L,&strat->Ll,cc,strat);
     }
@@ -8825 +9816 @@
   else if (BTEST1(12) || BTEST1(14) || BTEST1(16) || BTEST1(18))
     strat->posInT = posInT1;
-#ifdef HAVE_RINGS
   if (rField_is_Ring(currRing))
   {
@@ -8833 +9823 @@
     strat->posInT = posInT11;
   }
-#endif
   strat->posInLDependsOnLength = FALSE;
   strat->posInLSba  = posInLSig;
   //strat->posInL     = posInLSig;
   strat->posInL     = posInLF5C;
+  /*
+  if (rField_is_Ring(currRing))
+  {
+    strat->posInLSba  = posInLSigRing;
+    strat->posInL     = posInL11Ring;
+  }*/
   //strat->posInT     = posInTSig;
 }
@@ -8901 +9896 @@
     else
     {
-      /*Shdl=*/initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
-      // /*Shdl=*/initS(F, Q,strat); /*sets also S, ecartS, fromQ */
+      initSLSba(F, Q,strat); /*sets also S, ecartS, fromQ */
     }
   }
@@ -8925 +9919 @@
   omFreeSize((ADDRESS)strat->sevS,IDELEMS(strat->Shdl)*sizeof(unsigned long));
   omFreeSize((ADDRESS)strat->sevSig,IDELEMS(strat->Shdl)*sizeof(unsigned long));
-  omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
-  omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
-  if (strat->sbaOrder == 1)
-  {
-    omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
+  if(strat->syzmax>0)
+  {
+    omFreeSize((ADDRESS)strat->syz,(strat->syzmax)*sizeof(poly));
+    omFreeSize((ADDRESS)strat->sevSyz,(strat->syzmax)*sizeof(unsigned long));
+    if (strat->sbaOrder == 1)
+    {
+      omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
+    }
   }
   omFreeSize(strat->S_2_R,IDELEMS(strat->Shdl)*sizeof(int));
@@ -9594 +10591 @@
       //pWrite(p);
       //pWrite(strat->S[i]);
-      while(ok == FALSE)
+      while(ok == FALSE && p != NULL)
       {
         if(pLmDivisibleBy(strat->S[i], p))
@@ -9604 +10601 @@
         {
           pLmDelete(&p);
+          h->p = p;
           deleted = TRUE;
         }
@@ -9642 +10640 @@
     strat->initEcart(h);
 }
-#endif
-
-#ifdef HAVE_RINGS
+
+void postReduceByMonSig(LObject* h, kStrategy strat)
+{
+  if(!nCoeff_is_Ring_Z(currRing->cf))
+      return;
+  poly hSig = h->sig;
+  poly pH = h->GetP();
+  poly p,pp;
+  p = pH;
+  bool deleted = FALSE, ok = FALSE;
+  for(int i = 0; i<=strat->sl; i++)
+  {
+    p = pH;
+    if(pNext(strat->S[i]) == NULL)
+    {
+      while(ok == FALSE && p!=NULL)
+      {
+        if(pLmDivisibleBy(strat->S[i], p))
+        {
+          poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
+          sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
+          if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
+          {
+            number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
+            p_SetCoeff(p,dummy,currRing);
+          }
+          pDelete(&sigMult);
+        }
+        if(nIsZero(p->coef))
+        {
+          pLmDelete(&p);
+          h->p = p;
+          deleted = TRUE;
+        }
+        else
+        {
+          ok = TRUE;
+        }
+      }
+      pp = pNext(p);
+      while(pp != NULL)
+      {
+        if(pLmDivisibleBy(strat->S[i], pp))
+        {
+          poly sigMult = pDivideM(pHead(p),pHead(strat->S[i]));
+          sigMult = ppMult_mm(sigMult,pCopy(strat->sig[i]));
+          if(sigMult!= NULL && pLtCmp(hSig,sigMult) == 1)
+          {
+            number dummy = n_IntMod(pp->coef, strat->S[i]->coef, currRing->cf);
+            p_SetCoeff(pp,dummy,currRing);
+            if(nIsZero(pp->coef))
+            {
+              pLmDelete(&pNext(p));
+              pp = pNext(p);
+              deleted = TRUE;
+            }
+            else
+            {
+              p = pp;
+              pp = pNext(p);
+            }
+          }
+          else
+          {
+            p = pp;
+            pp = pNext(p);
+          }
+          pDelete(&sigMult);
+        }
+        else
+        {
+          p = pp;
+          pp = pNext(p);
+        }
+      }
+    }
+  }
+  h->SetLmCurrRing();
+  if(deleted)
+    strat->initEcart(h);
+  
+}
+
 /*!
   used for GB over ZZ: final reduction by constant elements
@@ -10088 +11166 @@
   if (lmBin != NULL)
     omMergeStickyBinIntoBin(lmBin, currRing->PolyBin);
-  if (tailBin != NULL)
+  if (tailBin != NULL && !rField_is_Ring(currRing))
     omMergeStickyBinIntoBin(tailBin,
                             (tailRing != NULL ? tailRing->PolyBin:

kernel/GBEngine/kutil.h

@@ -355 +355 @@
   int newIdeal;
   int minim;
+  #ifdef HAVE_RINGS
+  bool sigdrop; //This is used to check sigdrop in sba over Z
+  int nrsyzcrit; // counts how many pairs are deleted by SyzCrit
+  int nrrewcrit; // counts how many pairs are deleted by FaugereRewCrit
+  int sbaEnterS; // sba over Z strategy: if sigdrop element has _*gen(sbaEnterS+1), then 
+                 // add directly sbaEnterS elements into S
+  int blockred;  // counter for blocked reductions in redSig
+  int blockredmax;
+  #endif
   #ifdef HAVE_SHIFTBBA
   int lV;
@@ -419 +428 @@
 int posInS (const kStrategy strat, const int length, const poly p,
             const int ecart_p);
+int posInSMonFirst (const kStrategy strat, const int length, const poly p,
+            const int ecart_p);
+int posInIdealMonFirst (const ideal F, const poly p,int start = 0,int end = -1);
 int posInT0 (const TSet set,const int length,LObject &p);
 int posInT1 (const TSet set,const int length,LObject &p);
@@ -447 +459 @@
 int posInLSig (const LSet set, const int length,
                LObject* L,const kStrategy strat);
+int posInLSigRing (const LSet set, const int length,
+               LObject* L,const kStrategy strat);
 int posInLRing (const LSet set, const int length,
                LObject* L,const kStrategy strat);
@@ -455 +469 @@
              LObject* L,const kStrategy strat);
 int posInL11Ring (const LSet set, const int length,
+             LObject* L,const kStrategy strat);
+int posInLF5CRing (const LSet set, int start , const int length,
              LObject* L,const kStrategy strat);
 int posInL11Ringls (const LSet set, const int length,
@@ -492 +508 @@
 int redRiloc (LObject* h,kStrategy strat);
 void enterExtendedSpoly(poly h,kStrategy strat);
+void enterExtendedSpolySig(poly h,poly hSig,kStrategy strat);
 void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR = -1);
+void superenterpairsSig (poly h,poly hSig,int hFrom,int k,int ecart,int pos,kStrategy strat, int atR = -1);
 poly kCreateZeroPoly(long exp[], long cabsind, poly* t_p, ring leadRing, ring tailRing);
 long ind2(long arg);
@@ -509 +527 @@
 void pairs ();
 BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1, bool enterTstrong = FALSE);
+BOOLEAN sbaCheckGcdPair (LObject* h,kStrategy strat);
+BOOLEAN enterOneStrongPolySig (int i,poly p,poly sig,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1);
 void message (int i,int* reduc,int* olddeg,kStrategy strat,int red_result);
 void messageStat (int hilbcount,kStrategy strat);
+void messageStatSBA (int hilbcount,kStrategy strat);
 #ifdef KDEBUG
 void messageSets (kStrategy strat);
@@ -751 +772 @@
 poly preIntegerCheck(ideal F, ideal Q);
 void postReduceByMon(LObject* h, kStrategy strat);
+void postReduceByMonSig(LObject* h, kStrategy strat);
 void finalReduceByMon(kStrategy strat);
 #endif

kernel/GBEngine/nc.cc

@@ -306 +306 @@
     h2->m[j]=0;
     }
-    // W[1..idElems(I)]
+    // W[1..IDELEMS(I)]
     if (flag >0)
     {

kernel/GBEngine/syz1.cc

@@ -1992 +1992 @@
       while ((k<syzstr->length) && (rr[k]!=NULL))
       {
-        (*resolution)[k+1] = idSize(rr[k]);
+        (*resolution)[k+1] = idElem(rr[k]);
         k++;
       }

kernel/GBEngine/syz3.cc

@@ -238 +238 @@
 * only for tests
 */
-#ifdef SING_NDEBUG
-static void syTestPairs(SSet resPairs,int length,ideal /*old_generators*/)
-#else
 static void syTestPairs(SSet resPairs,int length,ideal old_generators)
-#endif
 {
   int i=0;

kernel/ideals.h

@@ -38 +38 @@
 //int id_PosConstant(ideal id, const ring r)
 #define idPosConstant(I) id_PosConstant(I,currRing)
-
-/// Count the effective size of an ideal
-/// (without the trailing allocated zero-elements)
-/// deprecated! (use IDELEMS)
-static inline int idSize(const ideal id)
-{
-  int j = IDELEMS(id) - 1;
-  poly* mm = id->m;
-  while ((j >= 0) && (mm[j] == NULL)) j--;
-  return (j + 1);
-}
-
 
 //BOOLEAN id_IsConstant(ideal id, const ring r);

kernel/numeric/mpr_base.cc

@@ -3122 +3122 @@
     for ( i= tdg; i >= 0; i-- )
     {
-      //if ( piter ) Print("deg %d, pDeg(piter) %d\n",i,pTotaldegree(piter));
       if ( piter && pTotaldegree(piter) == i )
       {

kernel/polys.h

@@ -122 +122 @@
 
 #define pLtCmp(p,q)            p_LtCmp(p,q,currRing)
+#define pLtCmpNoAbs(p,q)       p_LtCmpNoAbs(p,q,currRing)
 #define pLtCmpOrdSgnDiffM(p,q) p_LtCmpOrdSgnDiffM(p,q,currRing)
 #define pLtCmpOrdSgnDiffP(p,q) p_LtCmpOrdSgnDiffP(p,q,currRing)