Changeset ff38ee in git for kernel/GBEngine

Timestamp:

May 13, 2016, 1:27:46 PM (8 years ago)

Author:

Adi Popescu <adi_popescum@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

4596097b8e3e6df729c105beb4dafc60320b218b

Parents:

978a8c14d698f02ec7d3aef83bbb6613f67c74951c1d660c7201e1779c8af50b3966da3a6e5cbe7c

Message:

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

Location:

kernel/GBEngine

Files:

• kspoly.cc (modified) (6 diffs)
• kstd1.cc (modified) (4 diffs)
• kstd2.cc (modified) (32 diffs)
• kutil.cc (modified) (49 diffs)
• kutil.h (modified) (4 diffs)
• syz.cc (modified) (1 diff)

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)
+    #ifdef HAVE_RINGS
+    if(rField_is_Ring(currRing))
+    {
+      pSetCoeff(sigMult,nMult(nDiv(pGetCoeff(PR->p),pGetCoeff(PW->p)), pGetCoeff(sigMult)));
+    }
+    #endif
 //#if 1
 #ifdef DEBUGF5
@@ -244 +258 @@
     printf("--------------\n");
 #endif
-    int sigSafe = p_LmCmp(PR->sig,sigMult,currRing);
+    int sigSafe;
+    #ifdef HAVE_RINGS
+    if(rField_is_Ring(currRing))
+      sigSafe = p_LtCmp(PR->sig,sigMult,currRing);
+    else
+    #endif
+      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 +272 @@
 
 #endif
+    #ifdef HAVE_RINGS
+    if(rField_is_Ring(currRing))
+    {
+      // Set the sig
+      if(pLmCmp(PR->sig, sigMult) == 0)
+      {
+        //The sigs have the same lm, have to substract
+        PR->sig = pSub(PR->sig, pCopy(sigMult));
+        //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(sigSafe == -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;
+          return 3;
+        }
+      }
+    }
+    #endif
     //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;
@@ -361 +410 @@
   }
 #endif
-
 #if defined(KDEBUG) && defined(TEST_OPT_DEBUG_RED)
   if (TEST_OPT_DEBUG)

kernel/GBEngine/kstd1.cc

@@ -2503 +2503 @@
 #ifdef KDEBUG
   idTest(F);
-  idTest(Q);
+  if(Q != NULL)
+    idTest(Q);
 
 #if MYTEST
@@ -2526 +2527 @@
   else
 #endif
-#ifdef HAVE_RINGS
-  if (rField_is_Ring(currRing))
-    r=bba(F,Q,NULL,hilb,strat);
-  else
-#endif
   {
     if (rHasLocalOrMixedOrdering(currRing))
@@ -2544 +2540 @@
         r=sba(F,Q,*w,hilb,strat);
       else
+      { 
+        //It is set to True, just to know that it is the first run 
+        strat->sigdrop = FALSE;
+        strat->sbaEnterS = -1;
         r=sba(F,Q,NULL,hilb,strat);
+        #if ADIDEBUG
+        printf("\nSBA Run 1: %i elements (syzCrit = %i)\n",IDELEMS(r),strat->nrsyzcrit);
+        //idPrint(r);
+        //getchar();
+        #endif
+        int sbarun = 2;
+        while(strat->sigdrop)
+        {
+          r=sba(r,Q,NULL,hilb,strat);
+          #if ADIDEBUG
+          printf("SBA Run %i: %i elements (syzCrit = %i)\n",sbarun++,IDELEMS(r),strat->nrsyzcrit);
+          //idPrint(r);
+          //getchar();
+          #endif
+        }
+      }
     }
   }
@@ -2558 +2574 @@
 //Print("%d reductions canceled \n",strat->cel);
   HCord=strat->HCord;
-  delete(strat);
+  //delete(strat);
   if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
   return r;

kernel/GBEngine/kstd2.cc

@@ -20 +20 @@
 #endif /* ifndef SING_NDEBUG */
 
-#define ADIDEBUG 0
+#define ADIDEBUG 1
 #define ADIDEBUG_COUNT 0
+#define REV_BLOCK_SBA 0
+#define SIG_DROP_FIRST 1
 
 #if MYTEST
@@ -640 +642 @@
 }
 
-KINLINE int ksReducePolyTailSig(LObject* PR, TObject* PW, LObject* Red)
+KINLINE int ksReducePolyTailSig(LObject* PR, TObject* PW, LObject* Red, kStrategy strat)
 {
   BOOLEAN ret;
@@ -651 +653 @@
   pWrite(Red->GetLmCurrRing());
   */
-  ret = ksReducePolySig(Red, PW, 1, NULL, &coef);
-
+  ret = ksReducePolySig(Red, PW, 1, NULL, &coef, strat);
 
   if (!ret)
@@ -678 +679 @@
 int redSig (LObject* h,kStrategy strat)
 {
+  #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
@@ -711 +722 @@
     if (j < 0)
     {
-      return 1;
+      // over ZZ: cleanup coefficients by complete reduction with monomials
+      postReduceByMonSig(h, strat);
+      if(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;
+      }
     }
 
@@ -732 +794 @@
         break;
       if ((strat->T[i].pLength < li)
-         &&
-          p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
+         #ifdef HAVE_RINGS
+         && (!rField_is_Ring(currRing) || n_DivBy(pGetCoeff(h_p),pGetCoeff(strat->T[i].p),currRing->cf))
+         #endif
+         && p_LmShortDivisibleBy(strat->T[i].GetLmTailRing(), strat->sevT[i],
                                h_p, not_sev, strat->tailRing))
       {
@@ -772 +836 @@
     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
+    #ifdef HAVE_RINGS
+    if(rField_is_Ring(currRing) && h->p == NULL && h->sig == NULL)
+    {
+      //Trivial case catch
+      strat->sigdrop = FALSE;
+    }
+    if(rField_is_Ring(currRing) && strat->sigdrop)
+    {
+      return 1;
+    }
+    #endif
 #if SBA_PRINT_REDUCTION_STEPS
     if (sigSafe != 3)
@@ -874 +955 @@
     loop
     {
+      #ifdef HAVE_RINGS
+      if(rField_is_Ring(currRing) && strat->sigdrop)
+        break;
+      #endif
       Ln.SetShortExpVector();
       if (withT)
@@ -904 +989 @@
       }
       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);
+      #ifdef HAVE_RINGS
+      if(rField_is_Ring(currRing) && strat->sigdrop)
+      {
+        //Cannot break the loop here so easily
+        break;
+      }
+      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
+      #endif
+      #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)
@@ -935 +1038 @@
     L->pLength++;
   }
-
   all_done:
   Ln.Delete();
@@ -1560 +1662 @@
     }
     #endif
-    getchar();
+    //getchar();
     #endif
     #ifdef KDEBUG
@@ -1908 +2010 @@
   sba_interreduction_operations = 0;
 #endif
-
+  
   ideal F1 = F0;
   ring sRing, currRingOld;
@@ -1923 +2025 @@
   // 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];
+  #if REV_BLOCK_SBA || SIG_DROP_FIRST
+  //#ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing) && strat->sigdrop)
+  {
+    #if REV_BLOCK_SBA
+    for (int i=0; i<IDELEMS(F1);++i)
+      F->m[i] = F1->m[i];
+    #else
+    //Now I put the element on pos 0 already with enterS
+    #if 0
+    for (int i=IDELEMS(F1)-1; i>0;i--)
+      F->m[i] = F1->m[i-1];
+    F->m[0] = F1->m[IDELEMS(F1)-1];
+    #else
+    for (int i=0; i<IDELEMS(F1);++i)
+      F->m[i] = F1->m[i];
+    //Put the SigDrop element on the correct position (think of sbaEnterS)
+    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;
+    }
+    #endif
+    #endif
+  }
+  else
+  #endif
+  {
+    intvec *sort  = idSort(F1);
+    for (int i=0; i<sort->length();++i)
+      F->m[i] = F1->m[(*sort)[i]-1];
+  }
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+    strat->sigdrop = FALSE;
+  strat->nrsyzcrit = 0;
+  #endif
 #if SBA_INTERRED_START
   F = kInterRed(F,NULL);
@@ -1941 +2080 @@
   BOOLEAN withT     = TRUE;
   strat->max_lower_index = 0;
-
   //initBuchMoraCrit(strat); /*set Gebauer, honey, sugarCrit*/
   initSbaCrit(strat); /*set Gebauer, honey, sugarCrit*/
@@ -1953 +2091 @@
   srmax = strat->sl;
   reduc = olddeg = lrmax = 0;
-
 #ifndef NO_BUCKETS
   if (!TEST_OPT_NOT_BUCKETS)
@@ -1964 +2101 @@
 
   // strat->posInT = posInT_pLength;
-  kTest_TS(strat);
-
+  
 #ifdef KDEBUG
 #if MYTEST
@@ -1989 +2125 @@
   }
 
-
+  #if 1
+  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;
+  }
+  #endif
+  kTest_TS(strat);
 #ifdef KDEBUG
   //kDebugPrint(strat);
@@ -1996 +2146 @@
   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
@@ -2031 +2229 @@
       // initialize new syzygy rules for the next iteration step
       initSyzRules(strat);
-
     }
     /*********************************************************************
@@ -2040 +2237 @@
     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 */
 
@@ -2131 +2341 @@
       red_result = 2;
     }
+    #ifdef HAVE_RINGS
+    if(rField_is_Ring(currRing))
+    {
+      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);
+    }
+    #endif
+    #if ADIDEBUG
+    printf("\nAfter reduce (redresult=%i): \n",red_result);pWrite(strat->P.p);pWrite(strat->P.sig);
+    #endif
+    #ifdef HAVE_RINGS
+    //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;
+      }
+      else
+      {
+        #if ADIDEBUG
+        printf("\nStill Sigdrop - redRing reduced to:\n");pWrite(strat->P.p);
+        #endif
+        strat->enterS(strat->P, 0, strat, strat->tl);
+        break;
+      }
+    }
+    #endif
+    
     if (errorreported)  break;
 
@@ -2148 +2398 @@
         if (!kStratChangeTailRing(strat)) { Werror("OVERFLOW.."); break;}
     }
-
     // reduction to non-zero new poly
     if (red_result == 1)
@@ -2170 +2419 @@
       // the one with highest signature
       int pos = strat->sl+1;
-
 #ifdef KDEBUG
 #if MYTEST
@@ -2180 +2428 @@
       // 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))
+#ifdef HAVE_RINGS
+      if(rField_is_Ring(currRing))
+      {  
+        if ((TEST_OPT_REDSB)||(TEST_OPT_REDTAIL))
+          strat->P.p = redtailSba(&(strat->P),pos-1,strat, withT);
+      }
+      else
+#endif
+      {
+        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
+      #ifdef HAVE_RINGS
+      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
+#endif
+    #ifdef HAVE_RINGS
+    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);
+      if(!nGreaterZero(pGetCoeff(strat->P.p)))
+      {
+        strat->P.p = pNeg(strat->P.p);
+        strat->P.sig = pNeg(strat->P.sig);
+      }
+    }
+    #endif
 
     // remove sigsafe label since it is no longer valid for the next element to
@@ -2259 +2572 @@
 #ifdef HAVE_RINGS
       if (rField_is_Ring(currRing))
-        superenterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat, strat->tl);
+        superenterpairsSig(strat->P.p,strat->P.sig,strat->sl+1,strat->sl,strat->P.ecart,pos,strat, strat->tl);
       else
 #endif
         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);
+        #endif
       // posInS only depends on the leading term
+      
+      #ifdef HAVE_RINGS
+      if(rField_is_Ring(currRing) && strat->sigdrop)
+        break;
+      #endif
+      strat->P.sevSig = p_GetShortExpVector(strat->P.sig,currRing);
       strat->enterS(strat->P, pos, strat, strat->tl);
+      
       if(strat->sbaOrder != 1)
       {
@@ -2432 +2756 @@
         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)
@@ -2452 +2785 @@
     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 MYTEST
-  PrintS("bba finish GB: currRing: "); rWrite(currRing);
+  PrintS("sba finish GB: currRing: "); rWrite(currRing);
 #endif /* MYTEST */
   if (TEST_OPT_DEBUG) messageSets(strat);
@@ -2480 +2832 @@
     }
   }
-
   /* complete reduction of the standard basis--------- */
   if (TEST_OPT_REDSB)
@@ -2504 +2855 @@
   size_syz = strat->syzl;
 #endif
-  exitSba(strat);
 //  if (TEST_OPT_WEIGHTM)
 //  {
@@ -2516 +2866 @@
   if (TEST_OPT_PROT) messageStat(hilbcount,strat);
   if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
-
 #ifdef KDEBUG
 #if MYTEST
-  PrintS("bba_end: currRing: "); rWrite(currRing);
+  PrintS("sba_end: currRing: "); rWrite(currRing);
 #endif /* MYTEST */
 #endif /* KDEBUG */
@@ -2525 +2874 @@
   size_g_non_red  = IDELEMS(strat->Shdl);
 #endif
+  //This is again done better at the beginning of the next loop because else damage S
+  //Put the element that caused the sigdrop ast the beginning
+  #if 0
+  //#if SIG_DROP_FIRST
+  poly dummy;
+  dummy = pCopy(strat->Shdl->m[strat->sl]);
+  for(int k=strat->sl;k>=1;k--)
+  {
+    strat->Shdl->m[k] = strat->Shdl->m[k-1];
+    strat->sig[k] = strat->sig[k-1];
+  }
+  strat->Shdl->m[0] = dummy;
+  #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 REV_BLOCK_SBA
+  #if ADIDEBUG
+  printf("\nSBA Endrun before block reverse sigdrop sorting: \n");
+  for(k = 0; k<=strat->sl; k++)
+  {
+    printf("[%i]:",k);pWrite(strat->Shdl->m[k]);
+    if(strat->sig[k]!= NULL)
+      {printf("       ");pWrite(strat->sig[k]);}
+    else
+      printf("        0\n");
+  }
+  #endif
+  //Reverse Blockwise Sorting of output needed for the Sig Drop Problem
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing) && strat->sigdrop)
+  {
+    poly dummy;
+    int i,j;
+    for(i=0;i<=strat->sl;)
+    {
+      k = pGetComp(strat->sig[i]);
+      for(j = i; j<=strat->sl && strat->sig[j]!= NULL && pGetComp(strat->sig[j]) == k;++j)
+      {
+        //printf("\n%i is ok",j);
+      }
+      if(j == strat->sl && strat->sig[j] == NULL)
+        j++;
+      j--;
+      //printf("\ni = %i, j = %i\n",i,j);
+      //getchar();
+      for(k=0;k<(j-i)/2;k++)
+      {
+        //printf("\n%i <> %i\n",i+k,j-k);
+        dummy = pCopy(strat->Shdl->m[i+k]);
+        strat->Shdl->m[i+k] = strat->Shdl->m[j-k];
+        strat->Shdl->m[j-k] = pCopy(dummy);
+        p_Delete(&dummy, currRing);
+        if(strat->sig[i+k]!= NULL)
+          dummy = pCopy(strat->sig[i+k]);
+        else
+          dummy = NULL;
+        strat->sig[i+k] = strat->sig[j-k];
+        if(dummy!= NULL)
+        {
+          strat->sig[j-k] = pCopy(dummy);
+          p_Delete(&dummy, currRing);
+        }
+      }
+      i = j+1;
+    }
+  }
+  #endif
+  #if ADIDEBUG
+  printf("\nSBA Endrun after block reverse sigdrop sorting: \n");
+  for(k = 0; k<=strat->sl; k++)
+  {
+    printf("[%i]:",k);pWrite(strat->Shdl->m[k]);
+    if(strat->sig[k]!= NULL)
+      {printf("       ");pWrite(strat->sig[k]);}
+    else
+      printf("        0\n");
+  }
+  #endif
+  #endif
   if ((strat->sbaOrder == 1 || strat->sbaOrder == 3) && sRing!=currRingOld)
   {
@@ -2530 +3002 @@
     F0          = idrMoveR (F1, sRing, currRing);
     strat->Shdl = idrMoveR_NoSort (strat->Shdl, sRing, currRing);
+    rChangeCurrRing (sRing);
+    exitSba(strat);
+    rChangeCurrRing (currRingOld);
     rDelete (sRing);
   }
-  id_DelDiv(strat->Shdl, currRing);
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing) && !strat->sigdrop)
+  #endif
+    id_DelDiv(strat->Shdl, currRing);
   idSkipZeroes(strat->Shdl);
   idTest(strat->Shdl);

kernel/GBEngine/kutil.cc

@@ -12 +12 @@
 #define MYTEST 0
 
-#define ADIDEBUG 0
+#define ADIDEBUG 1
 
 #include <kernel/mod2.h>
@@ -513 +513 @@
      pGetShallowCopyDeleteProc(strat->tailRing, currRing) :
      NULL);
-
   for (j=0; j<=strat->tl; j++)
   {
@@ -534 +533 @@
         }
         else
-          pDelete(&p);
+        {
+          //pDelete(&p);
+          p = NULL;
+        }
         break;
       }
@@ -821 +823 @@
 {
   int i;
-
   // test P
   kFalseReturn(kTest_L(&(strat->P), strat->tailRing,
@@ -1524 +1525 @@
   return TRUE;
 }
+
+
+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 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
+      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
 
@@ -2054 +2281 @@
 #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
   assume(i<=strat->sl);
-
   int      l;
   poly m1 = NULL,m2 = NULL; // we need the multipliers for the s-polynomial to compute
@@ -2080 +2311 @@
 
   // 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  ");
@@ -2093 +2340 @@
   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
@@ -2107 +2354 @@
   Lp.checked  = 0;
 #endif
-  int sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
+  int sigCmp;
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+    sigCmp = p_LtCmp(pSigMult,sSigMult,currRing);
+  else
+  #endif
+    sigCmp = p_LmCmp(pSigMult,sSigMult,currRing);
 //#if 1
 #if DEBUGF5
@@ -2114 +2367 @@
   pWrite(sSigMult);
 #endif
+  //In the ring case we already build the sig
+  #ifdef HAVE_RINGS
+  if(rField_is_Ring(currRing))
+  {
+    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
+      Lp.p = pCopy(p);
+      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);
+  }
+  #endif
+  
+  #if 0  
   if(sigCmp==0)
   {
@@ -2131 +2444 @@
     return;
   }
+  #endif
   // testing by syzCrit = F5 Criterion
   // testing by rewCrit1 = Rewritten Criterion
@@ -2139 +2453 @@
       )
   {
+    #if ADIDEBUG
+    printf("\nDELETED!\n");
+    #endif
     pDelete(&pSigMult);
     pDelete(&sSigMult);
@@ -2166 +2483 @@
   else
   {
-    #ifdef HAVE_PLURAL
-    if ( rIsPluralRing(currRing) )
-    {
-      if(pHasNotCF(p, strat->S[i]))
-      {
-         if(ncRingType(currRing) == nc_lie)
-         {
-             // generalized prod-crit for lie-type
-             strat->cp++;
-             Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
-         }
-         else
-        if( ALLOW_PROD_CRIT(strat) )
-        {
-            // product criterion for homogeneous case in SCA
-            strat->cp++;
-            Lp.p = NULL;
+    //Build p
+    #ifdef HAVE_RINGS
+    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
+    #endif
+    {
+      #ifdef HAVE_PLURAL
+      if ( rIsPluralRing(currRing) )
+      {
+        if(pHasNotCF(p, strat->S[i]))
+        {
+           if(ncRingType(currRing) == nc_lie)
+           {
+               // generalized prod-crit for lie-type
+               strat->cp++;
+               Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i], currRing);
+           }
+           else
+          if( ALLOW_PROD_CRIT(strat) )
+          {
+              // product criterion for homogeneous case in SCA
+              strat->cp++;
+              Lp.p = NULL;
+          }
+          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
@@ -2191 +2532 @@
           assume(pNext(Lp.p)==NULL); // TODO: this may be violated whenever ext.prod.crit. for Lie alg. is used
           pNext(Lp.p) = strat->tail; // !!!
-        }
+
+        }
+
+
+  #if MYTEST
+        if (TEST_OPT_DEBUG)
+        {
+          PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
+          PrintS("p: "); pWrite(p);
+          PrintS("SPoly: "); pWrite(Lp.p);
+        }
+  #endif
+
       }
       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; // !!!
-
-      }
-
-
-#if MYTEST
-      if (TEST_OPT_DEBUG)
-      {
-        PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
-        PrintS("p: "); pWrite(p);
-        PrintS("SPoly: "); pWrite(Lp.p);
-      }
-#endif
-
-    }
-    else
-    #endif
-    {
-      assume(!rIsPluralRing(currRing));
-      Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
-#if MYTEST
-      if (TEST_OPT_DEBUG)
-      {
-        PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
-        PrintS("p: "); pWrite(p);
-        PrintS("commutative SPoly: "); pWrite(Lp.p);
-      }
-#endif
-
-      }
+      #endif
+      {
+        assume(!rIsPluralRing(currRing));
+        Lp.p = ksCreateShortSpoly(strat->S[i], p, strat->tailRing);
+  #if MYTEST
+        if (TEST_OPT_DEBUG)
+        {
+          PrintS("enterOnePairNormal::\n strat->S[i]: "); pWrite(strat->S[i]);
+          PrintS("p: "); pWrite(p);
+          PrintS("commutative SPoly: "); pWrite(Lp.p);
+        }
+  #endif
+
+        }
+    }
   }
   // 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)
@@ -2257 +2604 @@
     if (strat->rewCrit3(Lp.sig,~Lp.sevSig,Lp.p,strat,strat->sl+1)) {
       pLmFree(Lp.lcm);
+      #if ADIDEBUG
+      printf("\nrewCrit3 deletes it!\n");
+      #endif
       pDelete(&Lp.sig);
       Lp.lcm=NULL;
@@ -2298 +2648 @@
         (!rIsPluralRing(currRing))
 //      ||  (rIsPluralRing(currRing) && (ncRingType(currRing) != nc_lie))
+      #ifdef HAVE_RINGS 
+      && !rField_is_Ring(currRing)
+      #endif
        )
     {
@@ -2318 +2671 @@
     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);
   }
 }
@@ -3109 +3510 @@
       if ((isFromQ)&&(strat->fromQ!=NULL))
       {
-        for (j=0; j<=k; j++)
+        for (j=0; j<=k && !strat->sigdrop; j++)
         {
           if (!strat->fromQ[j])
@@ -3122 +3523 @@
       {
         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);
@@ -3131 +3532 @@
     else
     {
-      for (j=0; j<=k; j++)
+      for (j=0; j<=k && !strat->sigdrop; j++)
       {
         if ((pGetComp(h)==pGetComp(strat->S[j]))
@@ -3143 +3544 @@
     }
 
+#if 0
     if (new_pair)
     {
@@ -3152 +3554 @@
       strat->chainCrit(h,ecart,strat);
     }
+#endif
   }
 }
@@ -3767 +4170 @@
     }
   }
-/*
-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
@@ -3900 +4321 @@
 void superenterpairs (poly h,int k,int ecart,int pos,kStrategy strat, int atR)
 {
-#if ADIDEBUG
-  PrintS("\nEnter superenterpairs\n");
-  int iii = strat->Ll;
-  printf("\nstrat->tl = %i\n",strat->tl);
-#endif
   assume (rField_is_Ring(currRing));
   // enter also zero divisor * poly, if this is non zero and of smaller degree
   if (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
-//#if ADIDEBUG
-  #if 0
-  if(iii==strat->Ll)
-  {
-    PrintS("\n                enterExtendedSpoly has not changed the list L.\n");
-  }
-  else
-  {
-    PrintLn();
-    PrintS("\n                enterExtendedSpoly changed the list L:\n");
-    for(iii=0;iii<=strat->Ll;iii++)
-    {
-      Print("\n                L[%d]:\n",iii);
-      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
-      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
-      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
-    }
-  }
-  printf("\nstrat->tl = %i\n",strat->tl);
-  iii = strat->Ll;
-#endif
   initenterpairs(h, k, ecart, 0, strat, atR);
-//#if ADIDEBUG
-  #if 0
-  if(iii==strat->Ll)
-  {
-    PrintS("\n                initenterpairs has not changed the list L.\n");
-  }
-  else
-  {
-    PrintS("\n                initenterpairs changed the list L:\n");
-    for(iii=0;iii<=strat->Ll;iii++)
-    {
-      Print("\n                L[%d]:\n",iii);
-      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
-      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
-      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
-    }
-  }
-  printf("\nstrat->tl = %i\n",strat->tl);
-  iii = strat->Ll;
-#endif
   initenterstrongPairs(h, k, ecart, 0, strat, atR);
-//#if ADIDEBUG
-  #if 0
-  if(iii==strat->Ll)
-  {
-    PrintS("\n                initenterstrongPairs has not changed the list L.\n");
-  }
-  else
-  {
-    PrintS("\n                initenterstrongPairs changed the list L:\n");
-    for(iii=0;iii<=strat->Ll;iii++)
-    {
-      Print("\n                L[%d]:\n",iii);
-      PrintS("                     ");p_Write(strat->L[iii].p1,strat->tailRing);
-      PrintS("                     ");p_Write(strat->L[iii].p2,strat->tailRing);
-      PrintS("                     ");p_Write(strat->L[iii].p,strat->tailRing);
-    }
-  }
-  printf("\nstrat->tl = %i\n",strat->tl);
-  PrintS("\nEnd of superenterpairs\n");
-#endif
   clearSbatch(h, k, pos, strat);
-#if ADIDEBUG
-  printf("\nstrat->tl = %i\n",strat->tl);
-#endif
+}
+
+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 (!(rField_is_Domain(currRing))) enterExtendedSpoly(h, strat);
+  #if ADIDEBUG
+  printf("\n      Trying to add spolys\n");
+  #endif
+  initenterpairsSig(h, hSig, hFrom, k, ecart, 0, strat, atR);
+  #if ADIDEBUG
+  printf("\n      Trying to add gcd-polys\n");
+  #endif
+  initenterstrongPairsSig(h, hSig, hFrom,k, ecart, 0, strat, atR);
+  clearSbatch(h, k, pos, strat);
 }
 #endif
@@ -4938 +5306 @@
 {
 if (length<0) return 0;
-if (pLmCmp(set[length].sig,p->sig)== currRing->OrdSgn)
+if (pLtCmp(set[length].sig,p->sig)== currRing->OrdSgn)
   return length+1;
 
@@ -4948 +5316 @@
   if (an >= en-1)
   {
-    if (pLmCmp(set[an].sig,p->sig) == currRing->OrdSgn) return en;
+    if (pLtCmp(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;
+  if (pLtCmp(set[i].sig,p->sig) == currRing->OrdSgn) an=i;
   else                                      en=i;
   /*aend. fuer lazy == in !=- machen */
@@ -5042 +5410 @@
 {
 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;
@@ -5051 +5419 @@
   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 */
@@ -5685 +6053 @@
     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
@@ -5691 +6064 @@
       PrintS("DELETE!\n");
 #endif
+      #if ADIDEBUG
+      printf("\nsyzCrit:\n");pWrite(strat->syz[k]);pWrite(sig);
+      #endif
+      strat->nrsyzcrit++;
       //printf("- T -\n\n");
       return TRUE;
@@ -5734 +6111 @@
       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;
@@ -5746 +6134 @@
 BOOLEAN faugereRewCriterion(poly sig, unsigned long not_sevSig, poly /*lm*/, kStrategy strat, int start=0)
 {
+  //return FALSE;
   //printf("Faugere Rewritten Criterion\n");
 //#if 1
@@ -5760 +6149 @@
     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))
+    #endif
+    )
     {
 //#if 1
@@ -5766 +6159 @@
       PrintS("DELETE!\n");
 #endif
+printf("\nFaugere RewCrit: * divisible by *\n");pWrite(sig);pWrite(strat->sig[k]);
       return TRUE;
     }
@@ -5802 +6196 @@
 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);
@@ -5825 +6233 @@
 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)) {
+    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;
       break;
@@ -6735 +7153 @@
   if( strat->S[0] )
   {
-    if( strat->S[1] )
+    if( strat->S[1] && !rField_is_Ring(currRing))
     {
       omFreeSize(strat->syzIdx,(strat->syzidxmax)*sizeof(int));
@@ -6802 +7220 @@
         {
           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);
@@ -6842 +7268 @@
     {
       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);
@@ -7720 +8154 @@
   // 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)
   {
@@ -7726 +8162 @@
     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));
@@ -7745 +8185 @@
       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)
@@ -7869 +8311 @@
   #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);
@@ -8003 +8445 @@
 void enterSyz(LObject &p, kStrategy strat, int atT)
 {
+  #if ADIDEBUG
+  printf("\n  Entersyz:\n");pWrite(p.sig);
+  #endif
   int i;
   strat->newt = TRUE;
@@ -8032 +8477 @@
   //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;
@@ -8043 +8493 @@
   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);
     }
@@ -8591 +9052 @@
     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 */
     }
   }
@@ -8618 +9078 @@
   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));
@@ -9238 +9701 @@
         if(pLmDivisibleBy(strat->S[i], p))
         {
+          number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
+          p_SetCoeff(p,dummy,currRing);
+        }
+        if(nIsZero(p->coef))
+        {
+          pLmDelete(&p);
+          deleted = TRUE;
+        }
+        else
+        {
+          ok = TRUE;
+        }
+      }
+      pp = pNext(p);
+      while(pp != NULL)
+      {
+        if(pLmDivisibleBy(strat->S[i], pp))
+        {
+          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);
+        }
+      }
+    }
+  }
+  h->SetLmCurrRing();
+  if(deleted)
+    strat->initEcart(h);
+}
+
+void postReduceByMonSig(LObject* h, kStrategy strat)
+{
+  if(!nCoeff_is_Ring_Z(currRing->cf))
+      return;
+  printf("\npostreducebymon\n");
+  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)
+    {
+      printf("\n------------------\n");
+      pWrite(p);
+      pWrite(strat->S[i]);
+      while(ok == FALSE)
+      {
+        if(pLmDivisibleBy(strat->S[i], p))
+        {
+          poly dum = pDivideM(pHead(p),pHead(strat->S[i]));
+          pWrite(dum);getchar();
           number dummy = n_IntMod(p->coef, strat->S[i]->coef, currRing->cf);
           p_SetCoeff(p,dummy,currRing);

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 sbaEnterS; // sba over Z strategy: if sigdrop element has _*gen(sbaEnterS+1), then 
+                 // add directly sbaEnterS elements into S
+  #endif
   #ifdef HAVE_SHIFTBBA
   int lV;
@@ -485 +491 @@
 void enterExtendedSpoly(poly h,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);
@@ -501 +508 @@
 void pairs ();
 BOOLEAN enterOneStrongPoly (int i,poly p,int /*ecart*/, int /*isFromQ*/,kStrategy strat, int atR = -1, bool enterTstrong = FALSE);
+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);
@@ -740 +748 @@
 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/syz.cc

@@ -865 +865 @@
       {
         if ((pGetComp(res[i]->m[j])>l)
-        || ((i>1) && (res[i-1]->m[pGetComp(res[i]->m[j])-1]==NULL)))
+        // usual resolutions do not the following, but artifulal built may: (tr. #763)
+        //|| ((i>1) && (res[i-1]->m[pGetComp(res[i]->m[j])-1]==NULL))
+        )
         {
           WerrorS("input not a resolvent");