Changeset 645a19 in git

Timestamp:

Jul 20, 2009, 2:01:13 PM (14 years ago)

Author:

Motsak Oleksandr <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'ba3e3ef698fa0b7c5867199959cc83330073d3cb')

Children:

195b03db00f5e08ad6a891adcf3a7794a5dd00bf

Parents:

45c67dc7a3eec0097d1ad6ff5635d960cc089937

Message:

*motsak: deep kernel implementation of induced Schreyer ordering + helpers


git-svn-id: file:///usr/local/Singular/svn/trunk@11991 2c84dea3-7e68-4137-9b89-c4e89433aadc

Files:

• Singular/extra.cc (modified) (9 diffs)
• kernel/ideals.cc (modified) (15 diffs)
• kernel/ideals.h (modified) (2 diffs)
• kernel/kstd1.cc (modified) (7 diffs)
• kernel/kstd2.cc (modified) (10 diffs)
• kernel/kutil.cc (modified) (6 diffs)
• kernel/pInline2.h (modified) (4 diffs)
• kernel/p_polys.cc (modified) (3 diffs)
• kernel/ring.cc (modified) (50 diffs)
• kernel/ring.h (modified) (10 diffs)
• kernel/structs.h (modified) (5 diffs)

Singular/extra.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR      *
 *****************************************/
-/* $Id: extra.cc,v 1.307 2009-07-16 08:12:26 ederc Exp $ */
+/* $Id: extra.cc,v 1.308 2009-07-20 12:01:13 motsak Exp $ */
 /*
 * ABSTRACT: general interface to internals of Singular ("system" command)
@@ -88 +88 @@
 #endif
 
+#include "attrib.h"
+
 #if defined(HPUX_10) || defined(HPUX_9)
 extern "C" int setenv(const char *name, const char *value, int overwrite);
@@ -197 +199 @@
     leftv h=args->next;
 // ONLY documented system calls go here
-// Undocumented system calls go down into #ifdef HAVE_EXTENDED_SYSTEM
+// Undocumented system calls go down into jjEXTENDED_SYSTEM (#ifdef HAVE_EXTENDED_SYSTEM)
 /*==================== nblocks ==================================*/
     if (strcmp(sys_cmd, "nblocks") == 0)
@@ -725 +727 @@
 
 
+#if 0
+    /// Returns old SyzCompLimit, can set new limit
+    if(strcmp(sys_cmd,"SetSyzComp")==0)
+    {
+      res->rtyp = INT_CMD;
+      res->data = (void *)rGetCurrSyzLimit(currRing);
+      if ((h!=NULL) && (h->Typ()==INT_CMD))
+      {
+        const int iSyzComp = (int)((long)(h->Data()));
+        assume( iSyzComp > 0 );
+        rSetSyzComp( iSyzComp );
+      }
+
+      return FALSE;
+    }
+    /// Endowe the current ring with additional (leading) Syz-component ordering
+    if(strcmp(sys_cmd,"MakeSyzCompOrdering")==0)
+    {
+      extern ring rAssure_SyzComp(const ring r, BOOLEAN complete);
+
+//    res->data = rCurrRingAssure_SyzComp(); // changes current ring! :(
+      res->data = (void *)rAssure_SyzComp(currRing, TRUE);
+      res->rtyp = RING_CMD; // return new ring!
+
+      return FALSE;
+    }
+#endif
+
+    /// Same for Induced Schreyer ordering (ordering on components is defined by sign!)
+    if(strcmp(sys_cmd,"MakeInducedSchreyerOrdering")==0)
+    {
+      extern ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete, int sign);
+      int sign = 1;
+      if ((h!=NULL) && (h->Typ()==INT_CMD))
+      {
+        sign = (int)((long)(h->Data()));
+        assume( sign == 1 || sign == -1 );
+      }
+      res->data = (void *)rAssure_InducedSchreyerOrdering(currRing, TRUE, sign);
+      res->rtyp = RING_CMD; // return new ring!
+      return FALSE;
+    }
+
+    /// Returns old SyzCompLimit, can set new limit
+    if(strcmp(sys_cmd,"SetISReferrence")==0)
+    {
+      extern void rSetISReference(const ideal F, const int l, const int p, const intvec * componentWeights, const ring r);
+
+      if ((h!=NULL) && ( (h->Typ()==IDEAL_CMD) || (h->Typ()==MODUL_CMD)))
+       {
+        intvec * componentWeights = (intvec *)atGet(h,"isHomog",INTVEC_CMD); // No copy?!
+        const ideal F = (ideal)h->Data(); ; // No copy!
+        h=h->next;
+
+        int l = 0; // Starting syz-comp (1st: i+1)
+
+        if ((h!=NULL) && (h->Typ()==INT_CMD))
+        {
+          l = (int)((long)(h->Data())); h=h->next;
+        }
+
+        int p = 0; // which IS-block? p^th!
+
+        if ((h!=NULL) && (h->Typ()==INT_CMD))
+        {
+          p = (int)((long)(h->Data())); h=h->next;
+        }
+
+        // F & componentWeights belong to that ordering block of currRing now:
+        rSetISReference(F, l, p, componentWeights, currRing); // F and componentWeights will be copied!
+      }
+      else
+      {
+        WerrorS("`system(\"SetISReferrence\",<ideal/module>, [int, int])` expected");
+        return TRUE;
+      }
+      return FALSE;
+    }
+
+
+
+////////////////////////////////////////////////////////////////////////
+/// Additional interface functions to non-commutative subsystem (PLURAL)
+///
+
+
 #ifdef HAVE_PLURAL
 /*==================== Approx_Step  =================*/
@@ -1970 +2058 @@
     }
     else
+/*==================== poly debug ==================================*/
+      if(strcmp(sys_cmd,"p")==0)
+      {
 #ifdef RDEBUG
-/*==================== poly debug ==================================*/
-    if(strcmp(sys_cmd,"p")==0)
-    {
-      pDebugPrint((poly)h->Data());
-      return FALSE;
-    }
-    else
+        pDebugPrint((poly)h->Data());
+#endif
+        return FALSE;
+      }
+      else
 /*==================== ring debug ==================================*/
-    if(strcmp(sys_cmd,"r")==0)
-    {
-      rDebugPrint((ring)h->Data());
-      return FALSE;
-    }
-    else
-#endif
+      if(strcmp(sys_cmd,"r")==0)
+      {
+#ifdef RDEBUG
+        rDebugPrint((ring)h->Data());
+#endif
+        return FALSE;
+      }
+/*==================== generic debug ==================================*/
+      if(strcmp(sys_cmd,"DebugPrint")==0)
+      {
+        if( h->Typ() == RING_CMD)
+        {
+          const ring r = (const ring)h->Data();
+          rWrite(r);
+          PrintLn();
+#ifdef RDEBUG
+          rDebugPrint(r);
+#endif
+        }
+        else
+        if( h->Typ() == POLY_CMD || h->Typ() == VECTOR_CMD)
+        {
+          const int nTerms = 3;
+          const poly p = (const poly)h->Data();
+          p_DebugPrint(p, currRing, currRing, nTerms);
+        }
+        else
+        if( h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
+        {
+          const int nTerms = 3;
+          const ideal id = (const ideal)h->Data();
+          idShow(id, currRing, currRing, nTerms);
+        }
+
+        return FALSE;
+      } else
 /*==================== mtrack ==================================*/
     if(strcmp(sys_cmd,"mtrack")==0)
@@ -2589 +2707 @@
       {
         WerrorS("ideal expected");
-        return false;
+        return TRUE;
       } 
       
@@ -2604 +2722 @@
       res->rtyp=IDEAL_CMD;
       res->data=(ideal) F5main(G,r,opt);
-      return false;
+      return FALSE;
     }
     else
@@ -2615 +2733 @@
       {
         WerrorS("ideal expected");
-        return false;
+        return TRUE;
       } 
       
@@ -2622 +2740 @@
       res->rtyp=IDEAL_CMD;
       res->data=(ideal) f5cMain(G,r);
-      return false;
+      return FALSE;
     }
     else

kernel/ideals.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ideals.cc,v 1.74 2009-06-04 08:14:57 Singular Exp $ */
+/* $Id: ideals.cc,v 1.75 2009-07-20 12:00:50 motsak Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate ideals
@@ -9 +9 @@
 /* includes */
 #include "mod2.h"
+
+#ifndef NDEBUG
+# define MYTEST 0
+#else /* ifndef NDEBUG */
+# define MYTEST 0
+#endif /* ifndef NDEBUG */
+
 #include "structs.h"
 #include "omalloc.h"
@@ -26 +33 @@
 
 
-#define MYTEST 0
 
 
@@ -66 +72 @@
 //#ifndef __OPTIMIZE__
 // this is mainly for outputting an ideal within the debugger
-void idShow(ideal id)
-{
+void idShow(const ideal id, const ring lmRing, const ring tailRing, const int debugPrint)
+{
+  assume( debugPrint >= 0 );
+  
   if( id == NULL )
     Print("(NULL)");
@@ -73 +81 @@
   {
     Print("Module of rank %ld,real rank %ld and %d generators.\n",
-           id->rank,idRankFreeModule(id),IDELEMS(id));
-    for (int i=0;i<id->ncols*id->nrows;i++)
-    {
-      if (id->m[i]!=NULL)
-      {
-        Print("generator %d: ",i);pWrite(id->m[i]);
-      }
+          id->rank,idRankFreeModule(id, lmRing, tailRing),IDELEMS(id));
+
+    int j = (id->ncols*id->nrows) - 1;
+    while ((j > 0) && (id->m[j]==NULL)) j--;
+    for (int i = 0; i <= j; i++)
+    {
+      Print("generator %d: ",i); p_DebugPrint(id->m[i], lmRing, tailRing, debugPrint);
     }
   }
@@ -1323 +1331 @@
   Print("Prepare::h2: ");
   idPrint(h2);
+
+  for(j=0;j<IDELEMS(h2);j++) pTest(h2->m[j]);
+
 #endif
 #endif
@@ -1356 +1367 @@
 #endif
 
+  idTest(h2);
 
   h3 = kStd(h2,currQuotient,hom,w,NULL,syzcomp);
+
+#if MYTEST
+#ifdef RDEBUG
+  Print("Prepare::Output: ");
+  idPrint(h3);
+  for(j=0;j<IDELEMS(h2);j++) pTest(h3->m[j]);
+#endif
+#endif
+
+
   idDelete(&h2);
   return h3;
@@ -1377 +1399 @@
   int ii, idElemens_h1;
 
+  assume(h1 != NULL);
+
   idElemens_h1=IDELEMS(h1);
 #ifdef PDEBUG
@@ -1412 +1436 @@
   }
 
-  ideal s_h3=idPrepare(s_h1,h,k,w);
+  idTest(s_h1);
+
+  ideal s_h3=idPrepare(s_h1,h,k,w); // main (syz) GB computation
 
   if (s_h3==NULL)
@@ -1589 +1615 @@
 #if MYTEST
 #ifdef RDEBUG
-  Print("Input: ");
+  Print("idLiftStd Input: ");
   idPrint(s_h1);
 #endif
@@ -1599 +1625 @@
 #if MYTEST
 #ifdef RDEBUG
-  Print("Prepare: ");
+  Print("idLiftStd Prepare: ");
   idPrint(s_h3);
 #endif
@@ -1608 +1634 @@
 #if MYTEST
 #ifdef RDEBUG
-  Print("Temp: ");
+  Print("idLiftStd Temp: ");
   idPrint(s_h2);
 #endif
@@ -1646 +1672 @@
 #if MYTEST
 #ifdef RDEBUG
-  Print("Input'': ");
+  Print("idLiftStd Input'': ");
   idPrint(s_h3);
 #endif
@@ -1656 +1682 @@
 #if MYTEST
 #ifdef RDEBUG
-  Print("Temp Result: ");
+  Print("idLiftStd Temp Result: ");
   idPrint(s_h2);
 #endif
@@ -1701 +1727 @@
 #if MYTEST
 #ifdef RDEBUG
-  Print("Output STD Ideal: ");
+  Print("idLiftStd Output STD Ideal: ");
   idPrint(s_h3);
 
-  Print("Output Matrix: ");
+  Print("idLiftStd Output Matrix: ");
   iiWriteMatrix(*ma, "ma", 2, 4);
 #endif

kernel/ideals.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ideals.h,v 1.13 2009-02-12 16:19:23 motsak Exp $ */
+/* $Id: ideals.h,v 1.14 2009-07-20 12:00:50 motsak Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate ideals
@@ -22 +22 @@
 void id_ShallowDelete (ideal* h, ring r);
 /* Shows an ideal -- mainly for debugging */
-void idShow(ideal id);
+void idShow(const ideal id, const ring lmRing = currRing, const ring tailRing = currRing, const int debugPrint = 0);
   /*- initialise an ideal -*/
 ideal idMaxIdeal (int deg);

kernel/kstd1.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd1.cc,v 1.55 2009-07-17 11:31:10 Singular Exp $ */
+/* $Id: kstd1.cc,v 1.56 2009-07-20 12:00:50 motsak Exp $ */
 /*
 * ABSTRACT:
 */
 
+// TODO: why the following is here instead of mod2.h???
+
+// define if tailrings should be used
+#define HAVE_TAIL_RING
+
 // define if buckets should be used
 #define MORA_USE_BUCKETS
 
-// define if tailrings should be used
-#define HAVE_TAIL_RING
-
 #include "mod2.h"
+
+#ifndef NDEBUG
+# define MYTEST 0
+#else /* ifndef NDEBUG */
+# define MYTEST 0
+#endif /* ifndef NDEBUG */
+
+#if MYTEST 
+#ifdef HAVE_TAIL_RING
+#undef HAVE_TAIL_RING
+#endif /* ifdef HAVE_TAIL_RING */
+#endif /* if MYTEST */
+
 #include "structs.h"
 #include "omalloc.h"
@@ -1683 +1698 @@
           int newIdeal, intvec *vw)
 {
+  if(idIs0(F))
+    return idInit(1,F->rank);
+
   ideal r;
   BOOLEAN b=pLexOrder,toReset=FALSE;
@@ -1743 +1761 @@
 #ifdef KDEBUG
   idTest(F);
+  idTest(Q);
+
+#if MYTEST
+  PrintS("kSTD: currRing: "); rWrite(currRing);
+#endif
+
 #endif
 #ifdef HAVE_PLURAL
@@ -1891 +1915 @@
               int syzComp, int reduced)
 {
+  if(idIs0(F))
+    return idInit(1,F->rank);
+
   ideal r=NULL;
   int Kstd1_OldDeg = Kstd1_deg,i;
@@ -2017 +2044 @@
   if (p==NULL)
      return NULL;
+
+  poly pp = p;
+
+#ifdef HAVE_PLURAL
+  if(rIsSCA(currRing))
+  {
+    const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
+    const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
+    pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
+
+    if(Q == currQuotient)
+      Q = SCAQuotient(currRing);
+  }
+#endif
+
   if ((idIs0(F))&&(Q==NULL))
+  {
+#ifdef HAVE_PLURAL
+    if(p != pp)
+      return pp;
+#endif
     return pCopy(p); /*F+Q=0*/
+  }
+
+
   kStrategy strat=new skStrategy;
   strat->syzComp = syzComp;
   strat->ak = si_max(idRankFreeModule(F),pMaxComp(p));
 
-  poly pp = p;
-
-#ifdef HAVE_PLURAL
-  if(rIsSCA(currRing))
-  {
-    const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
-    const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
-    pp = p_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing);
-
-    if(Q == currQuotient)
-      Q = SCAQuotient(currRing);
-  }
-#endif
+
 
   poly res;
@@ -2062 +2100 @@
   if (idIs0(p))
     return idInit(IDELEMS(p),si_max(p->rank,F->rank));
+
+  ideal pp = p;
+#ifdef HAVE_PLURAL
+  if(rIsSCA(currRing))
+  {
+    const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
+    const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
+    pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
+
+    if(Q == currQuotient)
+      Q = SCAQuotient(currRing);
+  }
+#endif
+
+
   if ((idIs0(F))&&(Q==NULL))
+  {
+#ifdef HAVE_PLURAL
+    if(p != pp)
+      return pp;
+#endif
+
     return idCopy(p); /*F+Q=0*/
+  }
 
   kStrategy strat=new skStrategy;
@@ -2069 +2129 @@
   strat->ak = si_max(idRankFreeModule(F),idRankFreeModule(p));
 
-  ideal pp = p;
-#ifdef HAVE_PLURAL
-  if(rIsSCA(currRing))
-  {
-    const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
-    const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
-    pp = id_KillSquares(pp, m_iFirstAltVar, m_iLastAltVar, currRing, false);
-
-    if(Q == currQuotient)
-      Q = SCAQuotient(currRing);
-  }
-#endif
 
   if (pOrdSgn==-1)

kernel/kstd2.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd2.cc,v 1.98 2009-07-17 09:51:42 Singular Exp $ */
+/* $Id: kstd2.cc,v 1.99 2009-07-20 12:00:51 motsak Exp $ */
 /*
 *  ABSTRACT -  Kernel: alg. of Buchberger
@@ -8 +8 @@
 
 // #define PDEBUG 2
+
+// TODO: why the following is here instead of mod2.h???
+
 // define to enable tailRings
 #define HAVE_TAIL_RING
+
+#include "mod2.h"
+
+#ifndef NDEBUG
+# define MYTEST 0
+#else /* ifndef NDEBUG */
+# define MYTEST 0
+#endif /* ifndef NDEBUG */
+
+#if MYTEST 
+# ifdef HAVE_TAIL_RING
+#  undef HAVE_TAIL_RING
+# endif // ifdef HAVE_TAIL_RING
+#endif
+
 // define if no buckets should be used
 // #define NO_BUCKETS
 
-#include "mod2.h"
 #ifdef HAVE_PLURAL
 #define PLURAL_INTERNAL_DECLARATIONS 1
@@ -946 +963 @@
 #ifdef KDEBUG
 static int bba_count = 0;
-#endif
+#endif /* KDEBUG */
 void kDebugPrint(kStrategy strat);
 
@@ -954 +971 @@
   bba_count++;
   int loop_count = 0;
-#endif
+#endif /* KDEBUG */
   om_Opts.MinTrack = 5;
   int   srmax,lrmax, red_result = 1;
@@ -983 +1000 @@
   kTest_TS(strat);
 
+#ifdef KDEBUG
+#if MYTEST
+  PrintS("bba start GB: currRing: ");
+  rWrite(currRing);PrintLn(); rDebugPrint(currRing);
+  PrintLn();
+
+  if(strat->tailRing != NULL && strat->tailRing != currRing)
+  {
+    PrintS("bba start GB: tailRing: ");
+    rWrite(strat->tailRing);PrintLn(); rDebugPrint(strat->tailRing);
+  }
+#endif /* MYTEST */
+#endif /* KDEBUG */
+
 #ifdef HAVE_TAIL_RING
-  kStratInitChangeTailRing(strat);
+  if(!idIs0(F))
+    kStratInitChangeTailRing(strat);
 #endif
   if (BVERBOSE(23))
@@ -1093 +1125 @@
       int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
 
+#ifdef KDEBUG
+#if MYTEST
+      PrintS("New S: "); pDebugPrint(strat->P.p); PrintLn();
+#endif /* MYTEST */
+#endif /* KDEBUG */
+
       // reduce the tail and normalize poly
       // in the ring case we cannot expect LC(f) = 1,
@@ -1114 +1152 @@
 #ifdef KDEBUG
       if (TEST_OPT_DEBUG){PrintS("new s:");strat->P.wrp();PrintLn();}
-#endif
+#if MYTEST
+      PrintS("New (reduced) S: "); pDebugPrint(strat->P.p); PrintLn();
+#endif /* MYTEST */
+#endif /* KDEBUG */
 
       // min_std stuff
@@ -1185 +1226 @@
 #ifdef KDEBUG
     memset(&(strat->P), 0, sizeof(strat->P));
-#endif
+#endif /* KDEBUG */
     kTest_TS(strat);
   }
 #ifdef KDEBUG
+#if MYTEST
+  PrintS("bba finish GB: currRing: "); rWrite(currRing);
+#endif /* MYTEST */
   if (TEST_OPT_DEBUG) messageSets(strat);
-#endif
+#endif /* KDEBUG */
+
   if (TEST_OPT_SB_1)
   {
@@ -1240 +1285 @@
   if (TEST_OPT_PROT) messageStat(srmax,lrmax,hilbcount,strat);
   if (Q!=NULL) updateResult(strat->Shdl,Q,strat);
+
+#ifdef KDEBUG
+#if MYTEST
+  PrintS("bba_end: currRing: "); rWrite(currRing);
+#endif /* MYTEST */
+#endif /* KDEBUG */
+  idTest(strat->Shdl);
+
   return (strat->Shdl);
 }
@@ -1246 +1299 @@
 {
   assume(q!=NULL);
-  assume(!(idIs0(F)&&(Q==NULL)));
+  assume(!(idIs0(F)&&(Q==NULL))); // NF(q, std(0) in polynomial ring?
 
 // lazy_reduce flags: can be combined by |

kernel/kutil.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.cc,v 1.147 2009-07-10 15:13:56 Singular Exp $ */
+/* $Id: kutil.cc,v 1.148 2009-07-20 12:00:51 motsak Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -13 +13 @@
 #include <string.h>
 #include "mod2.h"
+
+#ifndef NDEBUG
+# define MYTEST 0
+#else /* ifndef NDEBUG */
+# define MYTEST 0
+#endif /* ifndef NDEBUG */
+
+
 #include <mylimits.h>
 #include "structs.h"
@@ -1393 +1401 @@
   pSetm(Lp.lcm);
 
-#define MYTEST 0
 
   if (strat->sugarCrit && ALLOW_PROD_CRIT(strat))
@@ -6239 +6246 @@
 BOOLEAN kStratChangeTailRing(kStrategy strat, LObject *L, TObject* T, unsigned long expbound)
 {
+  assume(strat->tailRing == currRing);
+
   if (expbound == 0) expbound = strat->tailRing->bitmask << 1;
   if (expbound >= currRing->bitmask) return FALSE;
@@ -6248 +6257 @@
                                   (strat->homog && pFDeg == pDeg && !(rField_is_Ring(currRing))), // TODO Oliver
 #else
-                                  (strat->homog && pFDeg == pDeg),
-#endif
-                                  !strat->ak,
-                                  expbound);
+                                  (strat->homog && pFDeg == pDeg), // omit_degree
+#endif
+                                  (strat->ak==0), // omit_comp if the input is an ideal 
+                                  expbound); // exp_limit
+
   if (new_tailRing == currRing) return TRUE;
 
@@ -6341 +6351 @@
   int i;
   Exponent_t e;
-  ring new_tailRing;
+//  ring new_tailRing; // What for???
 
   assume(strat->tailRing == currRing);

kernel/pInline2.h

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: pInline2.h,v 1.16 2009-05-29 13:57:35 motsak Exp $
+ *  Version: $Id: pInline2.h,v 1.17 2009-07-20 12:00:51 motsak Exp $
  *******************************************************************/
 #ifndef PINLINE2_H
@@ -50 +50 @@
         return (((long)((p)->exp[r->pOrdIndex]))-POLY_NEGWEIGHT_OFFSET);
       case ro_syzcomp:
-      case ro_syz:
+      case ro_syz: case ro_isTemp:  case ro_is:
       case ro_cp:
         i++;
@@ -75 +75 @@
         return (p)->exp[r->pOrdIndex]=o+POLY_NEGWEIGHT_OFFSET;
       case ro_syzcomp:
-      case ro_syz:
+      case ro_syz:  case ro_isTemp: case ro_is:
       case ro_cp:
         i++;
@@ -197 +197 @@
   // 1, 2, 3 - anything like 00011..11
   pAssume2((twobits >> 2) == 0);
-  const unsigned long _bitmasks[4] = {-1, 0x7fff, 0x7f, 0x3};
-  return bitmask & _bitmasks[twobits]; 
-}
-
-
-/// @Note: we may add some more info (6 ) into VarOffset and thus encode 
+  static const unsigned long _bitmasks[4] = {-1, 0x7fff, 0x7f, 0x3};
+  return bitmask & _bitmasks[twobits];
+}
+
+
+/// @Note: we may add some more info (6 ) into VarOffset and thus encode
 PINLINE2 int p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
 {

kernel/p_polys.cc

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: p_polys.cc,v 1.17 2009-06-10 15:34:50 Singular Exp $
+ *  Version: $Id: p_polys.cc,v 1.18 2009-07-20 12:00:51 motsak Exp $
  *******************************************************************/
 
@@ -173 +173 @@
           break;
         }
+        // Prefix for Induced Schreyer ordering
+        case ro_isTemp: // Do nothing?? (to be removed into suffix later on...?)
+        {
+          assume(p != NULL);
+
+#ifndef NDEBUG
+#if MYTEST
+          Print("isTemp ord in rSetm: pos: %d, p: ", pos);  p_DebugPrint(p, r, r, 0);
+#endif
+#endif
+          int c = p_GetComp(p, r);
+
+          assume( c >= 0 );
+          const int limit = o->data.is.limit;
+
+          assume( limit >= 0 );
+
+          // Let's simulate case ro_syz above....
+          // Should accumulate (by Suffix) and be a level indicator
+          const int* const pVarOffset = o->data.isTemp.pVarOffset;
+
+          assume( pVarOffset != NULL );
+
+          if( c > limit )
+            p->exp[o->data.isTemp.start] = 1;
+          else
+          {
+            p->exp[o->data.isTemp.start] = 0;
+          }
+
+          // TODO: Can this be done in the suffix???
+          for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
+          {
+            const int vo = pVarOffset[i];
+            if( vo != -1) // TODO: optimize: can be done once!
+            {
+              p_SetExp(p, p_GetExp(p, i, r), r, vo); // copy put them verbatim
+              assume( p_GetExp(p, r, vo) == p_GetExp(p, i, r) ); // copy put them verbatim
+            }
+          }
+
+        
+
+#ifndef NDEBUG
+          for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
+          {
+            const int vo = pVarOffset[i];
+            if( vo != -1) // TODO: optimize: can be done once!
+            {
+              assume( p_GetExp(p, r, vo) == p_GetExp(p, i, r) ); // copy put them verbatim
+            }
+          }
+
+#if MYTEST
+//          if( p->exp[o->data.isTemp.start] > 0 )
+//          {
+//            PrintS("Initial Value: "); p_DebugPrint(p, r, r, 1);
+//          }
+#endif
+#endif
+
+          break;
+        }
+
+        // Suffix for Induced Schreyer ordering
+        case ro_is:
+        {
+          assume(p != NULL);
+
+          int c = p_GetComp(p, r);
+
+          assume( c >= 0 );
+          const ideal F = o->data.is.F;
+          const int limit = o->data.is.limit;
+
+          if( F != NULL && c > limit )
+          {
+#ifndef NDEBUG
+#if MYTEST
+            Print("is ord in rSetm: pos: %d, c: %d, limit: %d\n", c, pos, limit); // p_DebugPrint(p, r, r, 1);
+#endif
+#endif
+
+            c -= limit;
+            assume( c > 0 );
+            c--;
+
+            assume( c < IDELEMS(F) ); // What about others???
+
+            const poly pp = F->m[c]; // get reference monomial!!!
+
+
+#ifndef NDEBUG
+#if MYTEST
+            Print("Respective F[c - %d: %d] pp: ", limit, c); 
+            p_DebugPrint(pp, r, r, 1);
+#endif
+#endif
+
+
+            if(pp == NULL) break;
+
+            const int start = o->data.is.start;
+            const int end = o->data.is.end;
+
+            assume(start <= end);
+            assume(pp != NULL);
+
+            for( int i = start; i <= end; i++) // v[0] may be here...
+              p->exp[i] += pp->exp[i]; // !!!!!!!! ADD corresponding LT(F)
+
+#ifndef NDEBUG
+            const int* const pVarOffset = o->data.is.pVarOffset;
+
+            assume( pVarOffset != NULL );
+
+            for( int i = 1; i <= r->N; i++ ) // No v[0] here!!!
+            {
+              const int vo = pVarOffset[i];
+              if( vo != -1) // TODO: optimize: can be done once!
+                assume( p_GetExp(p, r, vo) == (p_GetExp(p, i, r) + p_GetExp(pp, r, vo)) );
+            }
+            // TODO: how to check this for computed values???
+#endif
+#ifndef NDEBUG
+#if MYTEST
+            PrintS("IS::Suffix::Result: "); // p_Write(p, r, r);
+            p_DebugPrint(p, r, r, 1);
+#endif
+#endif
+
+          } else
+          {
+            const int* const pVarOffset = o->data.is.pVarOffset;
+
+            // What about v[0] - component: it will be added later by
+            // suffix!!!
+            // TODO: Test it!
+            const int vo = pVarOffset[0];
+            if( vo != -1 )
+              p->exp[vo] = c; // initial component v[0]!
+          }
+
+          break;
+        }
         default:
           dReportError("wrong ord in rSetm:%d\n",o->ord_typ);
@@ -337 +482 @@
       case ringorder_S:
       case ringorder_s:
+      case ringorder_IS:
       case ringorder_aa:
         break;

kernel/ring.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ring.cc,v 1.122 2009-07-10 15:13:57 Singular Exp $ */
+/* $Id: ring.cc,v 1.123 2009-07-20 12:00:51 motsak Exp $ */
 
 /*
@@ -11 +11 @@
 #include <math.h>
 #include "mod2.h"
+
+#ifndef NDEBUG
+# define MYTEST 0
+#else /* ifndef NDEBUG */
+# define MYTEST 0
+#endif /* ifndef NDEBUG */
+
 #include "structs.h"
 #include "omalloc.h"
@@ -38 +45 @@
 static const char * const ringorder_name[] =
 {
-  " ?", //ringorder_no = 0,
-  "a", //ringorder_a,
-  "A", //ringorder_a64,
-  "c", //ringorder_c,
-  "C", //ringorder_C,
-  "M", //ringorder_M,
-  "S", //ringorder_S,
-  "s", //ringorder_s,
-  "lp", //ringorder_lp,
-  "dp", //ringorder_dp,
-  "rp", //ringorder_rp,
-  "Dp", //ringorder_Dp,
-  "wp", //ringorder_wp,
-  "Wp", //ringorder_Wp,
-  "ls", //ringorder_ls,
-  "ds", //ringorder_ds,
-  "Ds", //ringorder_Ds,
-  "ws", //ringorder_ws,
-  "Ws", //ringorder_Ws,
-  "L", //ringorder_L,
-  "aa", //ringorder_aa
-  "rs", //ringorder_rs,
-  " _" //ringorder_unspec
+  " ?", ///< ringorder_no = 0,
+  "a", ///< ringorder_a,
+  "A", ///< ringorder_a64,
+  "c", ///< ringorder_c,
+  "C", ///< ringorder_C,
+  "M", ///< ringorder_M,
+  "S", ///< ringorder_S,
+  "s", ///< ringorder_s,
+  "lp", ///< ringorder_lp,
+  "dp", ///< ringorder_dp,
+  "rp", ///< ringorder_rp,
+  "Dp", ///< ringorder_Dp,
+  "wp", ///< ringorder_wp,
+  "Wp", ///< ringorder_Wp,
+  "ls", ///< ringorder_ls,
+  "ds", ///< ringorder_ds,
+  "Ds", ///< ringorder_Ds,
+  "ws", ///< ringorder_ws,
+  "Ws", ///< ringorder_Ws,
+  "L", ///< ringorder_L,
+  "aa", ///< ringorder_aa
+  "rs", ///< ringorder_rs,
+  "IS", ///<  ringorder_IS
+  " _" ///< ringorder_unspec
 };
 
@@ -68 +76 @@
 }
 
-// unconditionally deletes fields in r
+/// unconditionally deletes fields in r
 void rDelete(ring r);
-// set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
+/// set r->VarL_Size, r->VarL_Offset, r->VarL_LowIndex
 static void rSetVarL(ring r);
-// get r->divmask depending on bits per exponent
+/// get r->divmask depending on bits per exponent
 static unsigned long rGetDivMask(int bits);
-// right-adjust r->VarOffset
+/// right-adjust r->VarOffset
 static void rRightAdjustVarOffset(ring r);
 static void rOptimizeLDeg(ring r);
@@ -88 +96 @@
 //}
 
-// internally changes the gloabl ring and resets the relevant
-// global variables:
+/// internally changes the gloabl ring and resets the relevant
+/// global variables:
 void rChangeCurrRing(ring r)
 {
@@ -358 +366 @@
     Print("ordering %s", rSimpleOrdStr(r->order[l]));
 
-    if ((r->order[l] >= ringorder_lp)
+
+    if (r->order[l] == ringorder_s)
+    {
+      assume( l == 0 );
+#ifndef NDEBUG
+      Print("  syzcomp at %d",r->typ[l].data.syz.limit);
+#endif
+      continue;
+    }
+    else if (r->order[l] == ringorder_IS)
+    {
+#ifndef NDEBUG
+      if(r->block0[l] == 0 )
+        Print("::prefix");
+      else
+        Print("::suffix (sign: %d)", r->block0[l]);
+#endif
+      continue;
+    } else
+    if (
+    (  (r->order[l] >= ringorder_lp)
     ||(r->order[l] == ringorder_M)
     ||(r->order[l] == ringorder_a)
     ||(r->order[l] == ringorder_a64)
-    ||(r->order[l] == ringorder_aa))
+    ||(r->order[l] == ringorder_aa) ) && (r->order[l] < ringorder_IS) )
     {
       PrintS("\n//                  : names   ");
@@ -371 +399 @@
       }
     }
-#ifndef NDEBUG
-    else if (r->order[l] == ringorder_s)
-    {
-      Print("  syzcomp at %d",r->typ[l].data.syz.limit);
-    }
-#endif
 
     if (r->wvhdl[l]!=NULL)
@@ -391 +413 @@
             int64 *w=(int64 *)r->wvhdl[l];
             #if SIZEOF_LONG == 4
-            Print(" %*lld" ,nlen,w[i+j],i+j);
+                  Print("%*lld " ,nlen,w[i+j],i+j);
             #else
             Print(" %*ld"  ,nlen,w[i+j],i+j);
@@ -1483 +1505 @@
  * DOES NOT CALL rComplete
  */
-ring rCopy0(ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
+ring rCopy0(const ring r, BOOLEAN copy_qideal, BOOLEAN copy_ordering)
 {
   if (r == NULL) return NULL;
@@ -1623 +1645 @@
   if (r->qideal!=NULL)
   {
-    if (copy_qideal) res->qideal= idrCopyR_NoSort(r->qideal, r);
+    if (copy_qideal) res->qideal= idrCopyR_NoSort(r->qideal, r, res);
     //memset: else res->qideal = NULL;
   }
@@ -1928 +1950 @@
     {
       sro_ord* o=&(r->typ[pos]);
-      if ((o->ord_typ == ro_syzcomp) || (o->ord_typ == ro_syz)) 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;
     }
   }
@@ -2037 +2059 @@
   omCheckAddrSize(r->VarOffset,(r->N+1)*sizeof(*(r->VarOffset)));
   // test assumptions:
-  for(i=0;i<=r->N;i++)
+  for(i=0;i<=r->N;i++) // for all variables (i = 0..N)
   {
     if(r->typ!=NULL)
     {
-      for(j=0;j<r->OrdSize;j++)
-      {
-        if (r->typ[j].ord_typ==ro_cp)
-        {
-          if(((short)r->VarOffset[i]) == r->typ[j].data.cp.place)
-            dReportError("ordrec %d conflicts with var %d",j,i);
-        }
-        else
-          if ((r->typ[j].ord_typ!=ro_syzcomp)
-          && (r->VarOffset[i] == r->typ[j].data.dp.place))
-            dReportError("ordrec %d conflicts with var %d",j,i);
+      for(j=0;j<r->OrdSize;j++) // for all ordering blocks (j =0..OrdSize-1)
+      {
+        if(r->typ[j].ord_typ == ro_isTemp)
+        {
+          const int p = r->typ[j].data.isTemp.suffixpos;
+
+          if(p <= j)
+            dReportError("ordrec prefix %d is unmatched",j);
+
+          assume( p < r->OrdSize );
+
+          if(r->typ[p].ord_typ != ro_is)
+            dReportError("ordrec prefix %d is unmatched (suffix: %d is wrong!!!)",j, p);
+
+          // Skip all intermediate blocks for undone variables:
+          if(r->typ[j].data.isTemp.pVarOffset[i] != -1) // Check i^th variable
+          {
+            j = p - 1; // SKIP ALL INTERNAL BLOCKS...???
+            continue; // To make for check OrdSize bound...
+          }
+        } else
+        if (r->typ[j].ord_typ == ro_is)
+        {
+          // Skip all intermediate blocks for undone variables:
+          if(r->typ[j].data.is.pVarOffset[i] != -1)
+          {
+            // ???
+          }
+
+        } else
+        {
+          if (r->typ[j].ord_typ==ro_cp)
+          {
+            if(((short)r->VarOffset[i]) == r->typ[j].data.cp.place)
+              dReportError("ordrec %d conflicts with var %d",j,i);
+          }
+          else
+            if ((r->typ[j].ord_typ!=ro_syzcomp)
+            && (r->VarOffset[i] == r->typ[j].data.dp.place))
+              dReportError("ordrec %d conflicts with var %d",j,i);
+        }
       }
     }
@@ -2327 +2379 @@
 }
 
+
+static void rO_ISPrefix(int &place, int &bitplace, int &prev_ord,
+    long *o, int N, int *v, sro_ord &ord_struct)
+{
+  if ((prev_ord== 1) || (bitplace!=BITS_PER_LONG))
+    rO_Align(place,bitplace);
+  // since we add something afterwards - it's better to start with anew!?
+
+  ord_struct.ord_typ = ro_isTemp;
+  ord_struct.data.isTemp.start = place;
+  ord_struct.data.isTemp.pVarOffset = (int *)omMemDup(v);
+  ord_struct.data.isTemp.suffixpos = -1;
+
+  // We will act as rO_Syz on our own!!!
+  // Here we allocate an exponent as a level placeholder 
+  o[place]= -1;
+  prev_ord=-1;
+  place++;
+
+#if MYTEST
+  Print("rO_ISPrefix: place = %d, v: {", ord_struct.data.isTemp.start);
+
+  for( int i = 0; i <= N; i++ )
+    Print("v[%d]: %09x", i, ord_struct.data.isTemp.pVarOffset[i]);
+
+  PrintS("}!\n");
+#endif
+}
+static void rO_ISSuffix(int &place, int &bitplace, int &prev_ord, long *o,
+  int N, int *v, sro_ord *tmp_typ, int &typ_i, int sgn)
+{
+#if MYTEST
+  Print("rO_ISSuffix: place = %d\n", place);
+#endif
+
+  // Let's find previous prefix:
+  int typ_j = typ_i - 1;
+  while(typ_j >= 0)
+  {
+    if( tmp_typ[typ_j].ord_typ == ro_isTemp)
+      break;
+    typ_j --;
+  }
+
+  assume( typ_j >= 0 );
+
+  if( typ_j < 0 ) // Found NO prefix!!! :(
+    return;
+
+  assume( tmp_typ[typ_j].ord_typ == ro_isTemp );
+
+  // Get saved state:
+  const int start = tmp_typ[typ_j].data.isTemp.start;
+  int *pVarOffset = tmp_typ[typ_j].data.isTemp.pVarOffset;
+
+/*
+  // shift up all blocks
+  while(typ_j < (typ_i-1))
+  {
+    tmp_typ[typ_j] = tmp_typ[typ_j+1];
+    typ_j++;
+  }
+  typ_j = typ_i - 1; // No increment for typ_i
+*/
+  tmp_typ[typ_j].data.isTemp.suffixpos = typ_i;
+
+  // Let's keep that dummy for now...
+  typ_j = typ_i; // the typ to change!
+  typ_i++; // Just for now...
+
+
+#if MYTEST
+  PrintS("Changes in v: {");
+#endif
+
+  for( int i = 0; i <= N; i++ ) // Note [0] == component !!! No Skip?
+  {
+    // Was i-th variable allocated inbetween?
+    if( v[i] != pVarOffset[i] )
+    {
+      pVarOffset[i] = v[i]; // Save for later...
+      v[i] = -1; // Undo!
+      assume( pVarOffset[i] != -1 );
+#if MYTEST
+      Print("v[%d]: %010x", i, pVarOffset[i]);
+#endif
+    } else
+      pVarOffset[i] = -1; // No change here...
+  }
+
+  if( pVarOffset[0] != -1 )
+    pVarOffset[0] &= 0x0fff;
+
+#if MYTEST
+  PrintS("}!\n");
+#endif
+  sro_ord &ord_struct = tmp_typ[typ_j];
+
+
+  ord_struct.ord_typ = ro_is;
+  ord_struct.data.is.start = start;
+  ord_struct.data.is.end   = place;
+  ord_struct.data.is.pVarOffset = pVarOffset;
+
+
+  // What about component???
+//   if( v[0] != -1 ) // There is a component already...???
+//     if( o[ v[0] & 0x0fff ] == sgn )
+//     {
+//       pVarOffset[0] = -1; // NEVER USED Afterwards...
+//       return;
+//     }
+
+  
+  // Moreover: we need to allocate the module component (v[0]) here!
+  if( v[0] == -1) // It's possible that there was module component v0 at the begining (before prefix)!
+  {
+    // Start with a whole long exponent
+    if( bitplace != BITS_PER_LONG )
+      rO_Align(place, bitplace);
+
+    assume( bitplace == BITS_PER_LONG );
+    bitplace -= BITS_PER_LONG;
+    assume(bitplace == 0);
+    v[0] = place | (bitplace << 24); // Never mind whether pVarOffset[0] > 0!!!
+    o[place] = sgn; // Singnum for component ordering
+    prev_ord = sgn;
+  }
+}
+
+
 static unsigned long rGetExpSize(unsigned long bitmask, int & bits)
 {
@@ -2447 +2630 @@
   }
 }
+
+
+bool rSetISReference(const ideal F, const int i, const int p, const intvec * componentWeights, const ring r);
+
 
 /*2
@@ -2462 +2649 @@
   BOOLEAN need_other_ring;
   BOOLEAN omitted_degree = FALSE;
+
+  int iNeedInducedOrderingSetup = 0; ///< How many induced ordering block do we have?
   int bits;
 
@@ -2475 +2664 @@
   int i=0;
   int j=0; /*  i index in r, j index in res */
-  loop
+
+  for( int r_ord=r->order[i]; (r_ord != 0) && (i < nblocks); j++, r_ord=r->order[++i])
   {
     BOOLEAN copy_block_index=TRUE;
-    int r_ord=r->order[i];
+
     if (r->block0[i]==r->block1[i])
     {
@@ -2501 +2691 @@
     switch(r_ord)
     {
+      case ringorder_S:
+      {
+        dReportError("Error: unhandled ordering in rModifyRing: ringorder_S = [%d]", r_ord);
+        order[j]=r_ord; /*r->order[i];*/
+        break;
+      }
       case ringorder_C:
       case ringorder_c:
@@ -2547 +2743 @@
         }
         break;
+      case ringorder_IS:
+      {
+        if (omit_comp)
+        {
+          dReportError("Error: WRONG USAGE of rModifyRing: cannot omit component due to the ordering block [%d]: %d", i, r_ord);
+          omit_comp = FALSE;
+        }
+        order[j]=r_ord; /*r->order[i];*/
+        iNeedInducedOrderingSetup++;
+        break;
+      }
+      case ringorder_s:
+      {
+        assume((i == 0) && (j == 0));
+        if (omit_comp)
+        {
+          dReportError("Error: WRONG USAGE of rModifyRing: cannot omit component due to the ordering block [%d]: %d", i, r_ord);
+          omit_comp = FALSE;
+        }
+        order[j]=r_ord; /*r->order[i];*/
+        break;
+      }
       default:
         order[j]=r_ord; /*r->order[i];*/
@@ -2557 +2775 @@
       wvhdl[j]=r->wvhdl[i];
     }
-    i++;j++;
+
     // order[j]=ringorder_no; //  done by omAlloc0
-    if (i==nblocks) break;
   }
   if(!need_other_ring)
@@ -2603 +2820 @@
 
   // set syzcomp
-  if (res->typ != NULL && res->typ[0].ord_typ == ro_syz)
-  {
-    res->typ[0] = r->typ[0];
-    if (r->typ[0].data.syz.limit > 0)
-    {
-      res->typ[0].data.syz.syz_index
-        = (int*) omAlloc((r->typ[0].data.syz.limit +1)*sizeof(int));
-      memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
-             (r->typ[0].data.syz.limit +1)*sizeof(int));
-    }
+  if (res->typ != NULL)
+  {
+    if( res->typ[0].ord_typ == ro_syz) // "s" Always on [0] place!
+    {
+      res->typ[0] = r->typ[0]; // Copy struct!? + setup the same limit!
+
+      if (r->typ[0].data.syz.limit > 0)
+      {
+        res->typ[0].data.syz.syz_index
+          = (int*) omAlloc((r->typ[0].data.syz.limit +1)*sizeof(int));
+        memcpy(res->typ[0].data.syz.syz_index, r->typ[0].data.syz.syz_index,
+              (r->typ[0].data.syz.limit +1)*sizeof(int));
+      }
+    }
+
+    if( iNeedInducedOrderingSetup > 0 )
+    {
+      for(j = 0, i = 0; (i < nblocks) && (iNeedInducedOrderingSetup > 0); i++)
+        if( res->typ[i].ord_typ == ro_is ) // Search for suffixes!
+        {
+          ideal F = idrHeadR(r->typ[i].data.is.F, r, res); // Copy F from r into res!
+          assume(
+            rSetISReference(
+              F,  // WILL BE COPIED!
+              r->typ[i].data.is.limit,
+              j++,
+              r->typ[i].data.is.componentWeights, // WILL BE COPIED
+              res)
+            );
+          id_Delete(&F, res);
+          iNeedInducedOrderingSetup--;
+        }
+    } // Process all induced Ordering blocks! ...
   }
   // the special case: homog (omit_degree) and 1 block rs: that is global:
@@ -2631 +2871 @@
 
       // just go on..
+    }
+
+    if( rIsSCA(r) )
+    {
+      if( !sca_Force(res, scaFirstAltVar(r), scaLastAltVar(r)) )
+      WarnS("error in sca_Force!");
     }
   }
@@ -2686 +2932 @@
 }
 
-// construct lp ring with r->N variables, r->names vars....
+// construct lp, C ring with r->N variables, r->names vars....
 ring rModifyRing_Simple(ring r, BOOLEAN ommit_degree, BOOLEAN ommit_comp, unsigned long exp_limit, BOOLEAN &simple)
 {
@@ -2868 +3114 @@
       r->MixedOrder=TRUE;
       break;
+    case ringorder_IS:
+    { // TODO: What is r->ComponentOrder???
+      r->MixedOrder=TRUE;
+/*
+      if( r->block0[o] != 0 ) // Suffix has the comonent
+        r->ComponentOrder = r->block0[o];
+      else // Prefix has level...
+        r->ComponentOrder=-1;
+*/
+      break;
+    }
+
     default:
       dReportError("wrong internal ordering:%d at %s, l:%d\n",o_r,__FILE__,__LINE__);
@@ -2939 +3197 @@
   int** wvhdl = r->wvhdl;
 
-  if (order[0]==ringorder_S ||order[0]==ringorder_s)
+  if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
   {
     order++;
@@ -2956 +3214 @@
       ||(
     ((order[1]==ringorder_c)||(order[1]==ringorder_C)
-     ||(order[1]==ringorder_S)
+     ||(order[1]==ringorder_S) ||(order[1]==ringorder_IS)
      ||(order[1]==ringorder_s))
     && (order[0]!=ringorder_M)
@@ -2963 +3221 @@
   {
     if ((order[0]!=ringorder_unspec)
-    && ((order[1]==ringorder_C)||(order[1]==ringorder_S)||
+    && ((order[1]==ringorder_C)||(order[1]==ringorder_S)||(order[1]==ringorder_IS)||
         (order[1]==ringorder_s)))
       r->ComponentOrder=-1;
@@ -2988 +3246 @@
   else if (((order[0]==ringorder_c)
             ||(order[0]==ringorder_C)
-            ||(order[0]==ringorder_S)
+            ||(order[0]==ringorder_S) ||(order[0]==ringorder_IS)
             ||(order[0]==ringorder_s))
   && (order[1]!=ringorder_M)
   &&  (order[2]==0))
   {
-    if ((order[0]==ringorder_C)||(order[0]==ringorder_S)||
+    if ((order[0]==ringorder_C)||(order[0]==ringorder_S)|| (order[0]==ringorder_IS) ||
         order[0]==ringorder_s)
       r->ComponentOrder=-1;
@@ -3017 +3275 @@
   else
   {
-    if ((r->VectorOut)||(order[0]==ringorder_C)||(order[0]==ringorder_S)||(order[0]==ringorder_s))
+    if ((r->VectorOut)||(order[0]==ringorder_C)||(order[0]==ringorder_S)||(order[0]==ringorder_s) ||(order[0]==ringorder_IS))
     {
       rSetFirstWv(r, 1, order, block1, wvhdl);
@@ -3036 +3294 @@
     if ((order[0]!=ringorder_c)
         && (order[0]!=ringorder_C)
-        && (order[0]!=ringorder_S)
+        && (order[0]!=ringorder_S) && (order[0]!=ringorder_IS)
         && (order[0]!=ringorder_s))
     {
@@ -3141 +3399 @@
   int j=0;
   int j_bits=BITS_PER_LONG;
-  BOOLEAN need_to_add_comp=FALSE;
+
+  BOOLEAN need_to_add_comp=FALSE; // Only for ringorder_s and ringorder_S!
+
   for(i=0;i<n;i++)
   {
@@ -3341 +3601 @@
 
       case ringorder_S:
+        assume(typ_i == 0 && j == 0);
         rO_Syzcomp(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
         need_to_add_comp=TRUE;
@@ -3347 +3608 @@
 
       case ringorder_s:
-        rO_Syz(j, j_bits,prev_ordsgn, tmp_ordsgn,tmp_typ[typ_i]);
+        assume(typ_i == 0 && j == 0);
+        rO_Syz(j, j_bits, prev_ordsgn, tmp_ordsgn, tmp_typ[typ_i]);
         need_to_add_comp=TRUE;
         typ_i++;
         break;
 
+      case ringorder_IS:
+      {
+        const int s = r->block0[i];
+        assume( s >= -1 && s <= 1);
+
+        assume( r->block0[i] == r->block1[i] );
+
+        if(s == 0) // Prefix IS
+          rO_ISPrefix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ[typ_i++]); // What about prev_ordsgn?
+        else // s = +1 or -1 // Note: typ_i might be incrimented here inside!
+        {
+          rO_ISSuffix(j, j_bits, prev_ordsgn, tmp_ordsgn, r->N, v, tmp_typ, typ_i, s); // Suffix.
+          need_to_add_comp=FALSE;
+        }
+
+        break;
+      }
       case ringorder_unspec:
       case ringorder_no:
@@ -3441 +3720 @@
   i=0; // position
   j=0; // index in r->typ
-  if (i==r->pCompIndex) i++;
+  if (i==r->pCompIndex) i++; // IS???
   while ((j < r->OrdSize)
          && ((r->typ[j].ord_typ==ro_syzcomp) ||
-             (r->typ[j].ord_typ==ro_syz) ||
+             (r->typ[j].ord_typ==ro_syz) || (r->typ[j].ord_typ==ro_isTemp) || (r->typ[j].ord_typ==ro_is) ||
              (r->order[r->typ[j].order_index] == ringorder_aa)))
   {
     i++; j++;
   }
+  // No use of j anymore!!!????
+
   if (i==r->pCompIndex) i++;
-  r->pOrdIndex=i;
+  r->pOrdIndex=i; // How came it is "i" here???!!!! exp[r->pOrdIndex] is order of a poly... This may be wrong!!! IS
 
   // ----------------------------
@@ -3483 +3764 @@
   if (r->VarOffset != NULL)
   {
+    if (r->OrdSize!=0 && r->typ != NULL)
+    {
+      for(int i = 0; i < r->OrdSize; i++)
+        if( r->typ[i].ord_typ == ro_is) // Search for suffixes! (prefix have the same VarOffset)
+        {
+          id_Delete(&r->typ[i].data.is.F, r);
+          r->typ[i].data.is.F = NULL; // ?
+
+          if( r->typ[i].data.is.componentWeights != NULL )
+          {
+            delete r->typ[i].data.is.componentWeights;
+            r->typ[i].data.is.componentWeights = NULL; // ?
+          }
+          
+
+          if( r->typ[i].data.is.pVarOffset != NULL )
+          {
+            omFreeSize((ADDRESS)r->typ[i].data.is.pVarOffset, (r->N +1)*sizeof(int));
+            r->typ[i].data.is.pVarOffset = NULL; // ?
+          }
+        }
+        else if (r->typ[i].ord_typ == ro_syz)
+        {
+          if(r->typ[i].data.syz.limit > 0)
+            omFreeSize(r->typ[i].data.syz.syz_index, ((r->typ[i].data.syz.limit) +1)*sizeof(int)); 
+          r->typ[i].data.syz.syz_index = NULL;
+        } else if (r->typ[i].ord_typ == ro_syzcomp)
+        {
+          Warn( "rUnComplete : ord_typ == ro_syzcomp was unhandled!!! Possibly memory leak!!!"  );
+        }
+
+      omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord)); r->typ = NULL;
+    }
+
+    if (r->order != NULL)
+    {
+      // delete r->order!!!???
+    }
+
     if (r->PolyBin != NULL)
       omUnGetSpecBin(&(r->PolyBin));
 
     omFreeSize((ADDRESS)r->VarOffset, (r->N +1)*sizeof(int));
-    if (r->order != NULL)
-    {
-      if (r->order[0] == ringorder_s && r->typ[0].data.syz.limit > 0)
-      {
-        omFreeSize(r->typ[0].data.syz.syz_index,
-             (r->typ[0].data.syz.limit +1)*sizeof(int));
-      }
-    }
-    if (r->OrdSize!=0 && r->typ != NULL)
-    {
-      omFreeSize((ADDRESS)r->typ,r->OrdSize*sizeof(sro_ord));
-    }
+    
     if (r->ordsgn != NULL && r->CmpL_Size != 0)
       omFreeSize((ADDRESS)r->ordsgn,r->ExpL_Size*sizeof(long));
@@ -3618 +3927 @@
   // corresponds to ro_typ from ring.h:
   const char *TYP[]={"ro_dp","ro_wp","ro_wp64","ro_wp_neg","ro_cp",
-                     "ro_syzcomp", "ro_syz", "ro_none"};
+                     "ro_syzcomp", "ro_syz", "ro_isTemp", "ro_is", "ro_none"};
   int i,j;
 
@@ -3640 +3949 @@
   for(j=0;j<r->OrdSize;j++)
   {
-    Print("  typ %s",TYP[r->typ[j].ord_typ]);
-    Print("  place %d",r->typ[j].data.dp.place);
-    if (r->typ[j].ord_typ!=ro_syzcomp)
-    {
-      Print("  start %d",r->typ[j].data.dp.start);
-      Print("  end %d",r->typ[j].data.dp.end);
-      if ((r->typ[j].ord_typ==ro_wp)
-      || (r->typ[j].ord_typ==ro_wp_neg))
-      {
-        PrintS(" w:");
-        int l;
-        for(l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;l++)
-          Print(" %d",r->typ[j].data.wp.weights[l-r->typ[j].data.wp.start]);
-      }
-      else if (r->typ[j].ord_typ==ro_wp64)
-      {
-        PrintS(" w64:");
-        int l;
-        for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
-          Print(" %ld",(long)(((int64*)r->typ[j].data.wp64.weights64)+l-r->typ[j].data.wp64.start));
-      }
+    Print("  typ %s", TYP[r->typ[j].ord_typ]);
+
+    if (r->typ[j].ord_typ==ro_isTemp)
+    {
+      Print("  start (level) %d, suffixpos: %d, VO: ",r->typ[j].data.isTemp.start, r->typ[j].data.isTemp.suffixpos);
+
+#if MYTEST      
+      for( int k = 0; k <= r->N; k++)
+        if (r->typ[j].data.isTemp.pVarOffset[k] != -1)
+          Print("[%2d]: %09x; ", k, r->typ[j].data.isTemp.pVarOffset[k]);
+#endif
+    }
+    else
+    if (r->typ[j].ord_typ==ro_is)
+    {
+      Print("  start %d, end: %d: ",r->typ[j].data.is.start, r->typ[j].data.is.end);
+
+//      for( int k = 0; k <= r->N; k++) if (r->typ[j].data.is.pVarOffset[k] != -1) Print("[%2d]: %04x; ", k, r->typ[j].data.is.pVarOffset[k]);
+
+      Print("  limit %d\n  F: ",r->typ[j].data.is.limit); idShow(r->typ[j].data.is.F, r, r, 1);
+
+      PrintS("weights: ");
+      
+      if( r->typ[j].data.is.componentWeights == NULL )
+        PrintS("NULL == [0,...0]\n");
+      else
+      {
+        (r->typ[j].data.is.componentWeights)->show(); PrintLn();
+      }
+      
+    } else
+    {
+      Print("  place %d",r->typ[j].data.dp.place);
+
+      if (r->typ[j].ord_typ!=ro_syzcomp  && r->typ[j].ord_typ!=ro_syz)
+      {
+        Print("  start %d",r->typ[j].data.dp.start);
+        Print("  end %d",r->typ[j].data.dp.end);
+        if ((r->typ[j].ord_typ==ro_wp)
+        || (r->typ[j].ord_typ==ro_wp_neg))
+        {
+          PrintS(" w:");
+          for(int l=r->typ[j].data.wp.start;l<=r->typ[j].data.wp.end;l++)
+            Print(" %d",r->typ[j].data.wp.weights[l-r->typ[j].data.wp.start]);
+        }
+        else if (r->typ[j].ord_typ==ro_wp64)
+        {
+          PrintS(" w64:");
+          int l;
+          for(l=r->typ[j].data.wp64.start;l<=r->typ[j].data.wp64.end;l++)
+            Print(" %ld",(long)(((int64*)r->typ[j].data.wp64.weights64)+l-r->typ[j].data.wp64.start));
+          }
+        }
     }
     PrintLn();
@@ -3739 +4080 @@
 #endif // RDEBUG
 
+/// debug-print monomial poly/vector p, assuming that it lives in the ring R
+inline void m_DebugPrint(const poly p, const ring R)
+{
+  Print("\nexp[0..%d]\n", R->ExpL_Size - 1);
+  for(int i = 0; i < R->ExpL_Size; i++)
+    Print("%09lx ", p->exp[i]);
+  PrintLn();
+  Print("v0:%9ld ", p_GetComp(p, R));
+  for(int i = 1; i <= R->N; i++) Print(" v%d:%5d",i, p_GetExp(p, i, R));
+  PrintLn();
+}
+
+
+/// debug-print at most nTerms (2 by default) terms from poly/vector p,
+/// assuming that lt(p) lives in lmRing and tail(p) lives in tailRing.
+void p_DebugPrint(const poly p, const ring lmRing, const ring tailRing, const int nTerms)
+{
+  assume( nTerms >= 0 );
+  if( p != NULL )
+  {
+    assume( p != NULL );
+    
+    p_Write(p, lmRing, tailRing);
+
+    if( (p != NULL) && (nTerms > 0) )
+    {
+      assume( p != NULL );
+      assume( nTerms > 0 );
+
+      // debug pring leading term
+      m_DebugPrint(p, lmRing);
+
+      poly q = pNext(p); // q = tail(p)
+
+      // debug pring tail (at most nTerms-1 terms from it)
+      for(int j = nTerms - 1; (q !=NULL) && (j > 0); pIter(q), --j)
+        m_DebugPrint(q, tailRing);
+
+      if (q != NULL)
+        PrintS("...\n");    
+    }
+  }
+  else
+    PrintS("0\n");          
+}
+
+
+
 
 /*2
@@ -3791 +4180 @@
 
 // for the time being, this is still here
-static ring rAssure_SyzComp(ring r, BOOLEAN complete = TRUE);
-
-#define MYTEST 0
+static ring rAssure_SyzComp(const ring r, BOOLEAN complete = TRUE);
 
 ring rCurrRingAssure_SyzComp()
 {
-#ifdef HAVE_PLURAL
 #if MYTEST
   PrintS("rCurrRingAssure_SyzComp(), currRing:  \n");
@@ -3804 +4190 @@
   rDebugPrint(currRing);
 #endif
-#endif
-#endif
-
-  ring r = rAssure_SyzComp(currRing);
-
-  if (r != currRing)
-  {
-    ring old_ring = currRing;
+  PrintS("\n");
+#endif
+
+  ring r = rAssure_SyzComp(currRing, TRUE);
+
+  if( r != currRing )
+  {
     rChangeCurrRing(r);
     assume(currRing == r);
 
-#ifdef HAVE_PLURAL
-#if MYTEST
-    PrintS("rCurrRingAssure_SyzComp(): currRing': ");
-    rWrite(currRing);
-#ifdef RDEBUG
-    rDebugPrint(currRing);
-#endif
-#endif
-#endif
-
-
-    if (old_ring->qideal != NULL)
-    {
-      r->qideal = idrCopyR_NoSort(old_ring->qideal, old_ring);
-      assume(idRankFreeModule(r->qideal) == 0);
-      currQuotient = r->qideal;
-
-#ifdef HAVE_PLURAL
-      if( rIsPluralRing(r) )
-        if( nc_SetupQuotient(r, old_ring, true) )
-        {
-//          WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
-        }
-#endif
-    }
-
-#ifdef HAVE_PLURAL
-    assume((r->qideal==NULL) == (old_ring->qideal==NULL));
-    assume(rIsPluralRing(r) == rIsPluralRing(old_ring));
-    assume(rIsSCA(r) == rIsSCA(old_ring));
-    assume(ncRingType(r) == ncRingType(old_ring));
-#endif
-
-  }
-
-  assume(currRing == r);
-
-
-#ifdef HAVE_PLURAL
 #if MYTEST
   PrintS("\nrCurrRingAssure_SyzComp(): new currRing: \n");
@@ -3860 +4206 @@
   rDebugPrint(currRing);
 #endif
-#endif
-#endif
+  PrintS("\n");
+#endif
+  }
 
   return r;
 }
 
-static ring rAssure_SyzComp(ring r, BOOLEAN complete)
-{
-  if (r->order[0] == ringorder_s) return r;
+static ring rAssure_SyzComp(const ring r, BOOLEAN complete)
+{
+  if ( (r->order[0] == ringorder_s) ) return r;
+  if ( (r->order[0] == ringorder_IS) )
+  {
+    WarnS("rAssure_SyzComp in an IS ring!");
+//    return r;
+  }
   ring res=rCopy0(r, FALSE, FALSE);
   int i=rBlocks(r);
@@ -3905 +4257 @@
     assume(rIsPluralRing(r) == rIsPluralRing(res));
 #endif
-  }
+
+
+#ifdef HAVE_PLURAL
+    ring old_ring = r;
+
+#if MYTEST
+    PrintS("rCurrRingAssure_SyzComp(): temp r': ");
+    rWrite(r);
+#ifdef RDEBUG
+    rDebugPrint(r);
+#endif
+    PrintS("\n");
+#endif
+#endif
+
+
+    if (r->qideal!=NULL)
+    {
+      res->qideal= idrCopyR_NoSort(r->qideal, r, res);
+
+      assume(idRankFreeModule(res->qideal, res) == 0);
+
+#ifdef HAVE_PLURAL
+      if( rIsPluralRing(res) )
+        if( nc_SetupQuotient(res, r, true) )
+        {
+//          WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
+        }
+
+#endif
+      assume(idRankFreeModule(res->qideal, res) == 0);
+    }
+
+#ifdef HAVE_PLURAL
+    assume((res->qideal==NULL) == (old_ring->qideal==NULL));
+    assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
+    assume(rIsSCA(res) == rIsSCA(old_ring));
+    assume(ncRingType(res) == ncRingType(old_ring));
+#endif
+
+#if MYTEST
+    PrintS("rCurrRingAssure_SyzComp(): res: ");
+    rWrite(r);
+#ifdef RDEBUG
+    rDebugPrint(r);
+#endif
+    PrintS("\n");
+#endif
+
+  }
+
   return res;
 }
@@ -3979 +4381 @@
   if (r->qideal!=NULL)
   {
-     res->qideal=idrCopyR_NoSort(r->qideal,r);
+     res->qideal=idrCopyR_NoSort(r->qideal,r, res);
 #ifdef HAVE_PLURAL
      if (rIsPluralRing(res))
@@ -4120 +4522 @@
           WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
         }
-      assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
-      assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
-      assume(rIsSCA(new_r) == rIsSCA(old_r));
-      assume(ncRingType(new_r) == ncRingType(old_r));
-#endif
-    }
+#endif
+    }
+
+#ifdef HAVE_PLURAL
+    assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
+    assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
+    assume(rIsSCA(new_r) == rIsSCA(old_r));
+    assume(ncRingType(new_r) == ncRingType(old_r));
+#endif
+
     rTest(new_r);
     rTest(old_r);
@@ -4132 +4538 @@
 }
 
+// Moves _c or _C ordering to the last place AND adds _s on the 1st place
 ring rCurrRingAssure_SyzComp_CompLastBlock()
 {
-  ring new_r_1 = rAssure_CompLastBlock(currRing, FALSE);
-  ring new_r = rAssure_SyzComp(new_r_1, FALSE);
+  ring new_r_1 = rAssure_CompLastBlock(currRing, FALSE); // due to this FALSE - no completion!
+  ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
 
   if (new_r != currRing)
@@ -4164 +4571 @@
           WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
         }
-      assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
-      assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
-      assume(rIsSCA(new_r) == rIsSCA(old_r));
-      assume(ncRingType(new_r) == ncRingType(old_r));
-#endif
-    }
+#endif
+    }
+
+#ifdef HAVE_PLURAL
+    assume((new_r->qideal==NULL) == (old_r->qideal==NULL));
+    assume(rIsPluralRing(new_r) == rIsPluralRing(old_r));
+    assume(rIsSCA(new_r) == rIsSCA(old_r));
+    assume(ncRingType(new_r) == ncRingType(old_r));
+#endif
+
     rTest(new_r);
     rTest(old_r);
@@ -4215 +4626 @@
 
 
+ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete = TRUE, int sgn = 1)
+{ // TODO: ???? Add leading Syz-comp ordering here...????
+
+#if MYTEST
+    Print("rAssure_InducedSchreyerOrdering(r, complete = %d, sgn = %d): r: \n", complete, sgn);
+    rWrite(r);
+#ifdef RDEBUG
+    rDebugPrint(r);
+#endif
+    PrintS("\n");
+#endif
+
+
+  ring res=rCopy0(r, FALSE, FALSE); // No qideal & ordering copy.
+
+  int n = rBlocks(r); // Including trailing zero!
+
+  // Create 2 more blocks for prefix/suffix:
+  res->order=(int *)omAlloc0((n+2)*sizeof(int)); // 0  ..  n+1
+  res->block0=(int *)omAlloc0((n+2)*sizeof(int));
+  res->block1=(int *)omAlloc0((n+2)*sizeof(int));
+  int ** wvhdl =(int **)omAlloc0((n+2)*sizeof(int**));
+
+  // Encapsulate all existing blocks between induced Schreyer ordering markers: prefix and suffix!
+  // Note that prefix and suffix have the same ringorder marker and only differ in block[] parameters!
+
+  // new 1st block
+  int j = 0;
+  res->order[j] = ringorder_IS; // Prefix
+  // res->block0[j] = res->block1[j] = 0;
+  // wvhdl[j] = NULL;
+  j++;
+
+  for(int i = 0; (i <= n) && (r->order[i] != 0); i++, j++) // i = [0 .. n-1] <- non-zero old blocks
+  {
+    res->order [j] = r->order [i];
+    res->block0[j] = r->block0[i];
+    res->block1[j] = r->block1[i];
+
+    if (r->wvhdl[i] != NULL)
+    {
+      wvhdl[j] = (int*) omMemDup(r->wvhdl[i]);
+    } // else wvhdl[j] = NULL;
+  }
+
+  // new last block
+  res->order [j] = ringorder_IS; // Suffix
+  res->block0[j] = res->block1[j] = sgn; // Sign of v[o]: 1 for C, -1 for c
+  // wvhdl[j] = NULL;
+  j++;
+
+  // res->order [j] = 0; // The End!
+  res->wvhdl = wvhdl;
+
+  // j == the last zero block now!
+  assume(j == (n+1));
+  assume(res->order[0]==ringorder_IS);
+  assume(res->order[j-1]==ringorder_IS);
+  assume(res->order[j]==0);
+
+
+  if (complete)
+  {
+    rComplete(res, 1);
+
+#if MYTEST
+    PrintS("rAssure_InducedSchreyerOrdering(): temp res: ");
+    rWrite(res);
+#ifdef RDEBUG
+    rDebugPrint(res);
+#endif
+    PrintS("\n");
+#endif
+
+
+
+#ifdef HAVE_PLURAL
+    if (rIsPluralRing(r))
+    {
+      if ( nc_rComplete(r, res, false) ) // no qideal!
+      {
+        WarnS("error in nc_rComplete");      // cleanup?//      rDelete(res);//      return r;      // just go on..
+      }
+    }
+    assume(rIsPluralRing(r) == rIsPluralRing(res));
+#endif
+
+
+#ifdef HAVE_PLURAL
+    ring old_ring = r;
+
+#if MYTEST
+    PrintS("rAssure_InducedSchreyerOrdering(): temp nc res: ");
+    rWrite(res);
+#ifdef RDEBUG
+    rDebugPrint(res);
+#endif
+    PrintS("\n");
+#endif
+#endif
+
+
+    if (r->qideal!=NULL)
+    {
+      res->qideal= idrCopyR_NoSort(r->qideal, r, res);
+
+      assume(idRankFreeModule(res->qideal, res) == 0);
+
+#ifdef HAVE_PLURAL
+      if( rIsPluralRing(res) )
+        if( nc_SetupQuotient(res, r, true) )
+        {
+//          WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
+        }
+
+#endif
+      assume(idRankFreeModule(res->qideal, res) == 0);
+    }
+
+#ifdef HAVE_PLURAL
+    assume((res->qideal==NULL) == (old_ring->qideal==NULL));
+    assume(rIsPluralRing(res) == rIsPluralRing(old_ring));
+    assume(rIsSCA(res) == rIsSCA(old_ring));
+    assume(ncRingType(res) == ncRingType(old_ring));
+#endif
+  }
+
+  return res;
+}
+
+
+
+
+
 ring rCurrRingAssure_dp_S()
 {
@@ -4228 +4773 @@
 {
   return rCurrRingAssure_Global(ringorder_C, ringorder_dp);
+}
+
+/// Changes r by setting induced ordering parameters: limit and reference leading terms
+/// F belong to r, we will DO a copy! (same to componentWeights)
+/// We will use it AS IS!
+/// returns true is everything was allright!
+bool rSetISReference(const ideal F, const int i = 0, const int p = 0, const intvec * componentWeights = NULL, const ring r = currRing)
+{
+  // Put the reference set F into the ring -ordering -recor
+#if MYTEST
+  Print("rSetISReference(F, i: %d, p: %d, w)\nF:", i, p);
+  idShow(F, r, r, 1); // currRing!
+  PrintLn();
+  PrintS("w: ");
+  if(componentWeights == NULL)
+    PrintS("NULL\n");
+  else
+    componentWeights->show();
+#endif
+
+  // TEST THAT THERE ARE DEGs!!!
+  // assume( componentWeights == NULL  ); // ???
+  if( componentWeights != NULL )
+  {
+//    assure that the ring r has degrees!!!
+//    Add weights to degrees of F[i]
+  }
+
+  if (r->typ==NULL)
+  {
+    dReportError("Error: WRONG USE of rSetISReference: wrong ring! (typ == NULL)");
+    return false;
+  }
+
+  int j = p; // Which IS record to use...
+  for( int pos = 0; pos < r->OrdSize; pos++ )
+    if( r->typ[pos].ord_typ == ro_is)
+      if( j-- == 0 )
+      {
+#if MYTEST
+        Print("Changing record on pos: %d\nOld limit: %d --->> New Limit: %d\n", pos, r->typ[pos].data.is.limit, i);
+#endif
+
+        const ideal FF = idrHeadR(F, r, r);
+
+
+        if( r->typ[pos].data.is.F != NULL)
+        {
+#if MYTEST
+          PrintS("Deleting old reference set F... \n");        // idShow(r->typ[pos].data.is.F, r);         PrintLn();
+#endif
+          id_Delete(&r->typ[pos].data.is.F, r);
+          r->typ[pos].data.is.F = NULL;
+        }
+
+        assume(r->typ[pos].data.is.F == NULL);
+
+        
+        r->typ[pos].data.is.F = FF; // F is owened by ring now! TODO: delete at the end!
+
+        if(r->typ[pos].data.is.componentWeights != NULL)
+        {
+#if MYTEST
+          PrintS("Deleting old componentWeights: "); r->typ[pos].data.is.componentWeights->show(); PrintLn();
+#endif
+          delete r->typ[pos].data.is.componentWeights;
+          r->typ[pos].data.is.componentWeights = NULL;
+        }
+
+
+        assume(r->typ[pos].data.is.componentWeights == NULL);
+
+        if( componentWeights != NULL )
+          componentWeights = ivCopy(componentWeights); // componentWeights is owened by ring now! TODO: delete at the end!
+
+        r->typ[pos].data.is.componentWeights = componentWeights;
+
+        r->typ[pos].data.is.limit = i; // First induced component
+
+#if MYTEST
+        PrintS("New reference set FF : \n");        idShow(FF, r, r, 1);         PrintLn();
+#endif
+
+        return true;
+      }
+
+  dReportError("Error: WRONG USE of rSetISReference: specified ordering block was not found!!!" );
+  return false;
 }
 
@@ -4258 +4891 @@
     currRing->typ[0].data.syz.limit = k;
     currRing->typ[0].data.syz.curr_index++;
-  }
-  else if ((currRing->order[0]!=ringorder_c) && (k!=0))
+      
+  } else if(
+            (currRing->typ!=NULL) && 
+            (currRing->typ[0].ord_typ==ro_isTemp)
+           )
+  {
+//      (currRing->typ[currRing->typ[0].data.isTemp.suffixpos].data.is.limit == k)
+    Warn("rSetSyzComp(%d) in an IS ring! Be careful!", k);
+  } else
+  if ((currRing->order[0]!=ringorder_c) && (k!=0)) // ???
   {
     dReportError("syzcomp in incompatible ring");
@@ -4613 +5254 @@
       // should not occur:
       case ringorder_S:
+      case ringorder_IS:
       case ringorder_s:
       case ringorder_aa:
@@ -4691 +5333 @@
   if (src->qideal != NULL)
   {
-    idDelete(&(r->qideal));
+    id_Delete(&(r->qideal), r);
 
 #ifdef HAVE_PLURAL

kernel/ring.h

@@ -7 +7 @@
 * ABSTRACT - the interpreter related ring operations
 */
-/* $Id: ring.h,v 1.41 2009-05-06 12:53:49 Singular Exp $ */
+/* $Id: ring.h,v 1.42 2009-07-20 12:00:51 motsak Exp $ */
 
 /* includes */
@@ -28 +28 @@
 void   rKill(ring r);
 ring   rCopy(ring r);
-ring rCopy0(ring r, BOOLEAN copy_qideal = TRUE, BOOLEAN copy_ordering = TRUE);
+ring   rCopy0(const ring r, BOOLEAN copy_qideal = TRUE, BOOLEAN copy_ordering = TRUE);
 void   rNameCheck(ring R);
 ring   rOpposite(ring r);
 ring   rEnvelope(ring r);
 
-// we must always have this test!
+/// we must always have this test!
 inline bool rIsPluralRing(const ring r)
 {
@@ -248 +248 @@
 n_coeffType rFieldType(ring r);
 
-// this needs to be called whenever a new ring is created: new fields
-// in ring are created (like VarOffset), unless they already exist
-// with force == 1, new fields are _always_ created (overwritten),
-// even if they exist
+/// this needs to be called whenever a new ring is created: new fields
+/// in ring are created (like VarOffset), unless they already exist
+/// with force == 1, new fields are _always_ created (overwritten),
+/// even if they exist
 BOOLEAN rComplete(ring r, int force = 0);
-// use this to free fields created by rComplete
+// use this to free fields created by rComplete //?
 
 inline int rBlocks(ring r)
@@ -276 +276 @@
 }
 
-// order stuff
+/// order stuff
 typedef enum rRingOrder_t
 {
   ringorder_no = 0,
   ringorder_a,
-  ringorder_a64, // for int64 weights
+  ringorder_a64, ///< for int64 weights
   ringorder_c,
   ringorder_C,
   ringorder_M,
-  ringorder_S,
-  ringorder_s,
+  ringorder_S, ///< S?
+  ringorder_s, ///< s?
   ringorder_lp,
   ringorder_dp,
@@ -300 +300 @@
   ringorder_L,
   // the following are only used internally
-  ringorder_aa, // for idElimination, like a, except pFDeg, pWeigths ignore it
-  ringorder_rs,
+  ringorder_aa, ///< for idElimination, like a, except pFDeg, pWeigths ignore it
+  ringorder_rs, ///< ???
+  ringorder_IS, ///< Induced (Schreyer) ordering
   ringorder_unspec
 } rRingOrder_t;
@@ -307 +308 @@
 typedef enum rOrderType_t
 {
-  rOrderType_General = 0, // non-simple ordering as specified by currRing
-  rOrderType_CompExp,     // simple ordering, component has priority
-  rOrderType_ExpComp,     // simple ordering, exponent vector has priority
-                          // component not compatible with exp-vector order
-  rOrderType_Exp,         // simple ordering, exponent vector has priority
-                          // component is compatible with exp-vector order
-  rOrderType_Syz,         // syzygy ordering
-  rOrderType_Schreyer,    // Schreyer ordering
-  rOrderType_Syz2dpc,     // syzcomp2dpc
-  rOrderType_ExpNoComp    // simple ordering, differences in component are
-                          // not considered
+  rOrderType_General = 0, ///< non-simple ordering as specified by currRing
+  rOrderType_CompExp,     ///< simple ordering, component has priority
+  rOrderType_ExpComp,     ///< simple ordering, exponent vector has priority
+                          ///< component not compatible with exp-vector order
+  rOrderType_Exp,         ///< simple ordering, exponent vector has priority
+                          ///< component is compatible with exp-vector order
+  rOrderType_Syz,         ///< syzygy ordering
+  rOrderType_Schreyer,    ///< Schreyer ordering
+  rOrderType_Syz2dpc,     ///< syzcomp2dpc
+  rOrderType_ExpNoComp    ///< simple ordering, differences in component are
+                          ///< not considered
 } rOrderType_t;
 
-inline BOOLEAN rIsSyzIndexRing(ring r)
+inline BOOLEAN rIsSyzIndexRing(const ring r)
 { return r->order[0] == ringorder_s;}
 
-inline int rGetCurrSyzLimit(ring r = currRing)
-{ return (r->order[0] == ringorder_s ?
-          r->typ[0].data.syz.limit : 0);}
+inline int rGetCurrSyzLimit(const ring r = currRing)
+{ return (rIsSyzIndexRing(r)? r->typ[0].data.syz.limit : 0);}
 
 // Ring Manipulations
@@ -334 +334 @@
 ring   rCurrRingAssure_dp_C();
 ring   rCurrRingAssure_C_dp();
-// makes sure that c/C ordering is last ordering
+
+/// makes sure that c/C ordering is last ordering
 ring   rCurrRingAssure_CompLastBlock();
-// makes sure that c/C ordering is last ordering and SyzIndex is first
+
+/// makes sure that c/C ordering is last ordering and SyzIndex is first
 ring   rCurrRingAssure_SyzComp_CompLastBlock();
 ring rAssure_TDeg(ring r, int start_var, int end_var, int &pos);
 
-// return the max-comonent wchich has syzIndex i
-// Assume: i<= syzIndex_limit
+/// return the max-comonent wchich has syzIndex i
+/// Assume: i<= syzIndex_limit
 int rGetMaxSyzComp(int i);
 
 BOOLEAN rHasSimpleOrder(const ring r);
-// returns TRUE, if simple lp or ls ordering
+
+/// returns TRUE, if simple lp or ls ordering
 BOOLEAN rHasSimpleLexOrder(const ring r);
+
 // return TRUE if p->exp[r->pOrdIndex] holds total degree of p */
 //inline BOOLEAN rHasGlobalOrdering(const ring r=currRing)
@@ -357 +361 @@
 #define rHasLocalOrMixedOrdering_currRing() (pOrdSgn==-1)
 BOOLEAN rOrd_is_Totaldegree_Ordering(ring r =currRing);
-// return TRUE if p_SetComp requires p_Setm
+
+/// return TRUE if p_SetComp requires p_Setm
 BOOLEAN rOrd_SetCompRequiresSetm(ring r);
 rOrderType_t    rGetOrderType(ring r);
-/* returns TRUE if var(i) belongs to p-block */
+
+/// returns TRUE if var(i) belongs to p-block
 BOOLEAN rIsPolyVar(int i, ring r = currRing);
 
@@ -380 +386 @@
                          BOOLEAN omit_comp,
                          unsigned long exp_limit);
-// construct Wp, C ring
+
+/// construct Wp, C ring
 ring rModifyRing_Wp(ring r, int* weights);
 void rModify_a_to_A(ring r);
@@ -391 +398 @@
 void rKillModifiedRing_Simple(ring r);
 
+#ifdef RDEBUG
 void rDebugPrint(ring r);
 void pDebugPrint(poly p);
 void p_DebugPrint(poly p, const ring r);
+#endif
+
+/// debug-print at most nTerms (2 by default) terms from poly/vector p,
+/// assuming that lt(p) lives in lmRing and tail(p) lives in tailRing.
+void p_DebugPrint(const poly p, const ring lmRing, const ring tailRing, const int nTerms = 2);
 
 int64 * rGetWeightVec(ring r);

kernel/structs.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: structs.h,v 1.61 2009-05-29 16:21:04 Singular Exp $ */
+/* $Id: structs.h,v 1.62 2009-07-20 12:00:51 motsak Exp $ */
 /*
 * ABSTRACT
@@ -356 +356 @@
              // with possibly negative weights
   ro_cp,    // ordering duplicates variables
-  ro_syzcomp, // ordering indicates "subset" of component number
-  ro_syz, // ordering  with component number >syzcomp is lower
+  ro_syzcomp, // ordering indicates "subset" of component number (ringorder_S)
+  ro_syz, // ordering  with component number >syzcomp is lower (ringorder_s)
+  ro_isTemp, ro_is, // Induced Syzygy (Schreyer) ordering (and prefix data placeholder dummy) (ringorder_IS)
   ro_none
 }
@@ -422 +423 @@
 
 typedef struct sro_syz sro_syz;
+// Induced Syzygy (Schreyer) ordering is built inductively as follows:
+// we look for changes made by ordering blocks which are between prefix/suffix markers:
+// that is: which variables where placed by them and where (judging by v)
+
+// due to prefix/suffix nature we need some placeholder:
+// prefix stores here initial state
+// suffix cleares this up
+struct sro_ISTemp
+{
+  short start; // 1st member SHOULD be short "place"
+  int   suffixpos;
+  int*  pVarOffset; // copy!
+};
+
+// So this is the actuall thing!
+// suffix uses last sro_ISTemp (cleares it up afterwards) and
+// creates this block
+struct sro_IS
+{
+  short start, end;  // which part of L we want to want to update...
+  int*  pVarOffset; // same as prefix!
+
+  int limit; // first referenced component
+
+  // reference poly set?? // Should it be owned by ring?!!!
+  ideal F; // reference leading (module)-monomials set. owned by ring...
+  const intvec* componentWeights; // component weights! owned by ring...
+};
+
+typedef struct sro_IS sro_IS;
+typedef struct sro_ISTemp sro_ISTemp;
 
 #ifndef OM_ALLOC_H
@@ -439 +471 @@
      sro_syzcomp syzcomp;
      sro_syz syz;
+     sro_IS is;
+     sro_ISTemp isTemp;
   } data;
 };
@@ -631 +665 @@
   BOOLEAN   ShortOut;
   BOOLEAN   CanShortOut;
-  BOOLEAN   LexOrder;
-  // TRUE if the monomial ordering has polynomial and power series blocks
-  BOOLEAN   MixedOrder;
-  // TRUE for global/local mixed orderings, FALSE otherwise
-  BOOLEAN   ComponentOrder;
+  BOOLEAN   LexOrder; // TRUE if the monomial ordering has polynomial and power series blocks
+  BOOLEAN   MixedOrder; // TRUE for global/local mixed orderings, FALSE otherwise
+
+  BOOLEAN   ComponentOrder; // ???