Index: libpolys/polys/monomials/p_polys.cc
===================================================================
--- libpolys/polys/monomials/p_polys.cc	(revision e4f491963f9660b7e75c9817b20efcc8c5fae6fa)
+++ libpolys/polys/monomials/p_polys.cc	(revision 74f51f261514079d9bce01fd1a8ffed4de458527)
@@ -461,5 +461,5 @@
 {
   p_LmCheckPolyRing(a, r);
-  assume(p_GetOrder(a, r) == p_WTotaldegree(a, r));
+//  assume(p_GetOrder(a, r) == p_WTotaldegree(a, r)); // WRONG assume!
   return p_GetOrder(a, r);
 }
@@ -488,4 +488,5 @@
   p_LmCheckPolyRing(p, r);
   int i, k;
+  int pIS = 0; 
   long j =0;
 
@@ -540,7 +541,45 @@
       case ringorder_S:
       case ringorder_s:
-      case ringorder_IS:
       case ringorder_aa:
         break;
+      case ringorder_IS:
+      {
+        assume( b0 == b1 );
+        assume( (-2 < b0) && (b0 < 2) ); // 0 => prefix! +/-1 => suffix!
+
+        if( b0 != 0) // suffix?
+          break;
+
+        // only prefix adds the weight... 
+
+        if( (k = p_GetComp(p, r)) == 0 )
+          break;
+
+        const int ord_pos = rGetISPos(pIS++, r);
+        
+        const intvec* componentWeights = r->typ[ord_pos].data.is.componentWeights;
+
+        if( componentWeights == NULL )
+          break;
+              
+        const int limit = r->typ[ord_pos].data.is.limit;
+        assume( limit >= 0 );
+        
+        if( k > limit )
+        {
+          k -= (limit + 1);
+          assume( k >= 0 );
+          
+          assume( componentWeights != NULL );
+          
+          if( k < componentWeights->length() )
+            j += (*componentWeights)[k]; // j += the weight of k^th-component
+#ifndef NDEBUG
+          else
+            Warn("Unknown (out of known-range (%d)) component index:%d for IS[%d at %d] ordering\n",componentWeights->length(), k, pIS-1, ord_pos);
+#endif
+        }
+        break;
+      }
       case ringorder_a:
         for (k=b0 /*r->block0[i]*/;k<=b1 /*r->block1[i]*/;k++)
@@ -560,4 +599,54 @@
   return  j;
 }
+
+
+/// compute the total monomial weight for the case of Induced ordering,
+/// where we already have weight for module components!
+/// It is only needed to be known by rOptimizeLDeg and rSetDegStuff
+long p_TotaldegreeIS(poly p, const ring r)
+{
+  long s = p_Totaldegree(p, r);
+
+  int k = p_GetComp(p, r) - 1;
+
+  if ( (k > 0) && (r->typ!=NULL) )
+  {
+    int pIS = 0;
+    for( int pos = 0; pos < r->OrdSize; pos++ )
+      if( r->typ[pos].ord_typ == ro_is)
+      {
+        const intvec* componentWeights = r->typ[pos].data.is.componentWeights;
+
+        if( componentWeights == NULL )
+          continue;
+
+        const int limit = r->typ[pos].data.is.limit;
+        assume( limit >= 0 );
+        
+
+        if( k > limit )
+        {
+          k -= (limit + 1);
+          assume( k >= 0 );
+
+          assume( componentWeights != NULL );
+
+          if( k < componentWeights->length() )
+            s += (*componentWeights)[k]; // j += the weight of k^th-component
+#ifndef NDEBUG
+          else
+            Warn("Unknown (out of known-range (%d)) component index:%d for IS[%d at %d] ordering\n",componentWeights->length(), k, pIS-1, pos);
+#endif
+        }
+
+        pIS++;
+
+        return s; // multiple ro_is blocks are not really supported at the moment...
+      }
+  }
+
+  return s;
+}
+
 
 long p_DegW(poly p, const short *w, const ring R)
Index: libpolys/polys/monomials/p_polys.h
===================================================================
--- libpolys/polys/monomials/p_polys.h	(revision e4f491963f9660b7e75c9817b20efcc8c5fae6fa)
+++ libpolys/polys/monomials/p_polys.h	(revision 74f51f261514079d9bce01fd1a8ffed4de458527)
@@ -21,4 +21,5 @@
 #include <omalloc/omalloc.h>
 #include <misc/mylimits.h>
+#include <misc/intvec.h>
 #include <coeffs/coeffs.h>
 
Index: libpolys/polys/monomials/ring.cc
===================================================================
--- libpolys/polys/monomials/ring.cc	(revision e4f491963f9660b7e75c9817b20efcc8c5fae6fa)
+++ libpolys/polys/monomials/ring.cc	(revision 74f51f261514079d9bce01fd1a8ffed4de458527)
@@ -1906,5 +1906,9 @@
     {
       sro_ord* o=&(r->typ[pos]);
-      if ((o->ord_typ == ro_syzcomp) || (o->ord_typ == ro_syz) || (o->ord_typ == ro_is) || (o->ord_typ == ro_isTemp)) return TRUE;
+      if (   (o->ord_typ == ro_syzcomp)
+          || (o->ord_typ == ro_syz)
+          || (o->ord_typ == ro_is)
+          || (o->ord_typ == ro_isTemp))
+        return TRUE;
     }
   }
@@ -2047,5 +2051,5 @@
           if(r->typ[j].data.is.pVarOffset[i] != -1)
           {
-            // ???
+            // TODO???
           }
 
@@ -3059,11 +3063,11 @@
     case ringorder_IS:
     { // TODO: What is r->ComponentOrder???
-      r->MixedOrder=TRUE;
-/*
-      if( r->block0[o] != 0 ) // Suffix has the comonent
+//      r->MixedOrder=TRUE;
+      if( r->block0[o] != 0 ) // Suffix has the component
         r->ComponentOrder = r->block0[o];
-      else // Prefix has level...
+/*      else // Prefix has level...
         r->ComponentOrder=-1;
 */
+      // TODO: think about this a bit...!?
       break;
     }
@@ -3141,4 +3145,6 @@
   int** wvhdl = r->wvhdl;
 
+  
+
   if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
   {
@@ -3227,6 +3233,6 @@
 
     /*the number of orderings:*/
-    int i = 0;
-    while (order[++i] != 0);
+    int i = 0; while (order[++i] != 0);
+
     do
     {
@@ -3253,6 +3259,24 @@
     r->pFDeg = p_Deg;
 
+  if( rGetISPos(0, r) != -1 ) // Are there Schreyer induced blocks?
+  {
+    if( r->pFDeg == p_Totaldegree )
+    {
+      extern long p_TotaldegreeIS(poly p, const ring r);
+      r->pFDeg = p_TotaldegreeIS;
+    }
+#ifndef NDEBUG    
+    else
+      assume( r->pFDeg == p_Deg || r->pFDeg == p_WTotaldegree );
+#endif
+    
+    r->pLDeg = pLDeg1;
+  }
+
   r->pFDegOrig = r->pFDeg;
+  // NOTE: this leads to wrong ecart during std
+  // in Old/sre.tst
   rOptimizeLDeg(r); // also sets r->pLDegOrig
+
 }
 
@@ -3991,5 +4015,5 @@
 
       if( r->typ[j].data.is.componentWeights == NULL )
-        PrintS("NULL == [0,...0]\n");
+        PrintS("NULL == [0,...,0]\n");
       else
       {
@@ -4073,15 +4097,21 @@
 
   {
+    extern long p_TotaldegreeIS(poly p, const ring r);
+
+      PrintLn();
+      Print("pFDeg   : ");
 #define pFDeg_CASE(A) if(r->pFDeg == A) PrintS( "" #A "" )
-    Print("\npFDeg   : ");
-
-    pFDeg_CASE(p_Totaldegree); else
+      pFDeg_CASE(p_Totaldegree); else
       pFDeg_CASE(p_WFirstTotalDegree); else
       pFDeg_CASE(p_WTotaldegree); else
       pFDeg_CASE(p_Deg); else
+      pFDeg_CASE(p_TotaldegreeIS); else
+#undef pFDeg_CASE
+      
       Print("(%p)", (void*)(r->pFDeg)); // default case
 
-    PrintS("\n");
-#undef pFDeg_CASE
+    PrintLn();
+    Print("pLDeg   : (%p)", (void*)(r->pLDeg));    
+    PrintLn();
   }
 
@@ -4787,4 +4817,5 @@
 /// Finds p^th IS ordering, and returns its position in r->typ[]
 /// returns -1 if something went wrong!
+/// p - starts with 0!
 int rGetISPos(const int p, const ring r)
 {
@@ -4797,5 +4828,5 @@
   if (r->typ==NULL)
   {
-    dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
+//    dReportError("'rIsIS:' Error: wrong ring! (typ == NULL)");
     return -1;
   }
@@ -4805,7 +4836,5 @@
     if( r->typ[pos].ord_typ == ro_is)
       if( j-- == 0 )
-      {
         return pos;
-      }
 
   return -1;
Index: libpolys/polys/monomials/ring.h
===================================================================
--- libpolys/polys/monomials/ring.h	(revision e4f491963f9660b7e75c9817b20efcc8c5fae6fa)
+++ libpolys/polys/monomials/ring.h	(revision 74f51f261514079d9bce01fd1a8ffed4de458527)
@@ -741,4 +741,7 @@
 BOOLEAN rSetISReference(const ring r, const ideal F, const int i = 0, const int p = 0, const intvec * componentWeights = NULL);
 
+/// return the position of the p^th IS block order block in r->typ[]...
+int rGetISPos(const int p, const ring r);
+
 BOOLEAN rCheckIV(intvec *iv);
 int rTypeOfMatrixOrder(intvec * order);
