Changeset 52e2f6 in git

Timestamp:

Jun 10, 2008, 12:17:33 PM (16 years ago)

Author:

Motsak Oleksandr <motsak@…>

Branches:

(u'spielwiese', 'd1b01e9d51ade4b46b745d3bada5c5f3696be3a8')

Children:

28325ab307b0d45f178c4ce869547de7d3f3faa7

Parents:

f2b58394b7c0b28984794adfcef85f56f72e35bf

Message:

*motsak: major redesign of NC Subsystem, maybe something more...


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

Location:

kernel

Files:

• RULES (modified) (1 diff)
• gr_kstd2.cc (modified) (8 diffs)
• gring.cc (modified) (59 diffs)
• gring.h (modified) (14 diffs)
• ideals.cc (modified) (12 diffs)
• kstd1.cc (modified) (4 diffs)
• kutil.cc (modified) (9 diffs)
• longalg.cc (modified) (2 diffs)
• maps.cc (modified) (6 diffs)
• matpol.cc (modified) (5 diffs)
• matpol.h (modified) (2 diffs)
• pInline2.h (modified) (4 diffs)
• p_Procs_Set.h (modified) (3 diffs)
• ratgring.cc (modified) (3 diffs)
• ring.cc (modified) (30 diffs)
• ring.h (modified) (4 diffs)
• sca.cc (modified) (41 diffs)
• sca.h (modified) (7 diffs)
• structs.h (modified) (3 diffs)
• syz.cc (modified) (2 diffs)

kernel/RULES

@@ -1 +1 @@
 * never use fopen, but myfopen, in order to open text files
 
-* call rComplete after constructing a ring
+* call rComplete after constructing a ring (returns purely commutative ring!)
+
+** call nc_CallPlural to make a newly constucted commutative ring (see above) noncommutative 
 
 * never allocate memory with 0 as size request

kernel/gr_kstd2.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: gr_kstd2.cc,v 1.13 2007-02-07 10:49:39 Singular Exp $ */
+/* $Id: gr_kstd2.cc,v 1.14 2008-06-10 10:17:31 motsak Exp $ */
 /*
 *  ABSTRACT -  Kernel: noncomm. alg. of Buchberger
@@ -500 +500 @@
       {
         strat->fromT=FALSE;
-        (*h).p = gnc_ReduceSpolyNew(pi,(*h).p,strat->kNoether,currRing);
+        (*h).p = nc_ReduceSpoly(pi,(*h).p,strat->kNoether,currRing);
       }
       else
@@ -814 +814 @@
 }
 
+#define MYTEST 0
+
 ideal gnc_gr_bba(const ideal F, const ideal Q, const intvec *, const intvec *, kStrategy strat)
 {
+#if MYTEST
+   PrintS("<gnc_gr_bba>\n");
+#endif
+
+#ifdef HAVE_PLURAL
+#if MYTEST
+   PrintS("currRing: \n");
+   rWrite(currRing);
+#ifdef RDEBUG
+   rDebugPrint(currRing);
+#endif
+
+   PrintS("F: \n");
+   idPrint(F);  
+   PrintS("Q: \n");  
+   idPrint(Q);
+#endif
+#endif
+
+
+   
   assume(pOrdSgn != -1); // no mora!!! it terminates only for global ordering!!! (?)
 
@@ -835 +858 @@
   srmax = strat->sl;
   reduc = olddeg = lrmax = 0;
+
   /* compute------------------------------------------------------- */
   while (strat->Ll >= 0)
   {
     if (strat->Ll > lrmax) lrmax =strat->Ll;/*stat.*/
+
     if (TEST_OPT_DEBUG) messageSets(strat);
+
     if (strat->Ll== 0) strat->interpt=TRUE;
     if (TEST_OPT_DEGBOUND
@@ -858 +884 @@
     strat->Ll--;
     //kTest(strat);
+
+    if (strat->P.p != NULL)
     if (pNext(strat->P.p) == strat->tail)
     {
@@ -863 +891 @@
       pLmFree(strat->P.p);
       /* the real one */
-      if ((ncRingType(currRing)==nc_lie) && pHasNotCF(strat->P.p1,strat->P.p2)) /* prod crit */
-      {
-        strat->cp++;
-        /* prod.crit itself in nc_CreateSpoly */
-      }
+      if (ncRingType(currRing)==nc_lie) /* prod crit */
+        if(pHasNotCF(strat->P.p1,strat->P.p2))
+        {
+//          strat->cp++;
+          /* prod.crit itself in nc_CreateSpoly */
+        }
+      
       strat->P.p = nc_CreateSpoly(strat->P.p1,strat->P.p2,currRing);
-    }
+
+#ifdef PDEBUG
+      p_Test(strat->P.p, currRing);
+#endif
+
+#if MYTEST
+      if (TEST_OPT_DEBUG)
+      {
+        PrintS("p1: "); pWrite(strat->P.p1);
+        PrintS("p2: "); pWrite(strat->P.p2);
+        PrintS("SPoly: "); pWrite(strat->P.p);
+      }
+#endif      
+    }
+
+    
     if (strat->P.p != NULL)
     {
       if (TEST_OPT_PROT)
-      message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
+        message((strat->honey ? strat->P.ecart : 0) + strat->P.pFDeg(),
               &olddeg,&reduc,strat, red_result);
+
+#if MYTEST
+      if (TEST_OPT_DEBUG)
+      {
+        PrintS("p1: "); pWrite(strat->P.p1);
+        PrintS("p2: "); pWrite(strat->P.p2);
+        PrintS("SPoly before: "); pWrite(strat->P.p);
+      }
+#endif
+
       /* reduction of the element chosen from L */
       strat->red(&strat->P,strat);
+
+#if MYTEST
+      if (TEST_OPT_DEBUG)
+      {
+        PrintS("red SPoly: "); pWrite(strat->P.p);
+      }
+#endif
+
     }
     if (strat->P.p != NULL)
@@ -913 +976 @@
               if (TEST_OPT_DEBUG)
               {
-                PrintS("new s:");
-                wrp(strat->P.p);
+                PrintS("new s:"); wrp(strat->P.p);
                 PrintLn();
+#if MYTEST
+                Print("s: "); pWrite(strat->P.p);
+#endif
+                
               }
               // kTest(strat);
               //
               enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat);
+              
               if (strat->sl==-1) pos=0;
               else pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
+              
               strat->enterS(strat->P,pos,strat,-1);
             }
@@ -977 +1045 @@
 /*   Print("Total pairs considered:%d\n",zaehler); zaehler=0; */
 #endif /*PDEBUG*/
+
+#if MYTEST
+  PrintS("</gnc_gr_bba>\n");
+#endif
+
   return (strat->Shdl);
 }

kernel/gring.cc

@@ -7 +7 @@
  *  Author:  levandov (Viktor Levandovsky)
  *  Created: 8/00 - 11/00
- *  Version: $Id: gring.cc,v 1.53 2008-05-15 17:24:36 motsak Exp $
+ *  Version: $Id: gring.cc,v 1.54 2008-06-10 10:17:31 motsak Exp $
  *******************************************************************/
+
+#define OM_CHECK 4
+#define OM_TRACK 5
+
 #include "mod2.h"
 
@@ -26 +30 @@
 #include "p_Mult_q.h"
 
+#include "pInline1.h"
+   
 #include "gring.h"
 #include "sca.h"
+
+
+#define MYTEST 0
+#define OUTPUT 0
+
 
 // dirty tricks:
@@ -85 +96 @@
 //  poly nc_p_Plus_mm_Mult_qq (poly p, const poly m, const poly q, int &lp, int lq, const ring r);
 #endif
+
+
+
+/*2
+* returns the LCM of the head terms of a and b
+*/
+poly p_Lcm(const poly a, const poly b, const long lCompM, const ring r)
+{
+  poly m = p_ISet(1, r);
+
+  const int pVariables = r->N;
+
+  for (int i = pVariables; i; i--)
+  {
+    const int lExpA = p_GetExp (a, i, r);
+    const int lExpB = p_GetExp (b, i, r);
+
+    p_SetExp (m, i, si_max(lExpA, lExpB), r);
+  }
+
+  p_SetComp (m, lCompM, r);
+
+  p_Setm(m,r);
+
+#ifdef PDEBUG
+  p_Test(m,r);
+#endif
+
+  return(m);
+};
+
+poly p_Lcm(const poly a, const poly b, const ring r)
+{
+#ifdef PDEBUG
+  p_Test(a, r);
+  p_Test(b, r);
+#endif
+
+  const long lCompP1 = p_GetComp(a, r);
+  const long lCompP2 = p_GetComp(b, r);
+
+  const poly m = p_Lcm(a, b, si_max(lCompP1, lCompP2), r);
+  
+#ifdef PDEBUG
+  p_Test(m,r);
+#endif
+  return(m);
+};
 
 
@@ -254 +313 @@
     if (side)
         {
-      Print("Multiplication in the left module from the right");
+      Print("gnc_p_Mult_mm: Multiplication in the left module from the right");
     }
 #endif
@@ -379 +438 @@
   if (ncRingType(r)==nc_skew)
   {
-    if (r->nc->IsSkewConstant==1)
+    if (r->GetNC()->IsSkewConstant==1)
     {
       int tpower=0;
@@ -395 +454 @@
         }
       }
-      cff = n_Copy(p_GetCoeff(MATELEM(r->nc->COM,1,2),r),r);
+      cff = n_Copy(p_GetCoeff(MATELEM(r->GetNC()->COM,1,2),r),r);
       nPower(cff,tpower,&tmp_num);
       n_Delete(&cff,r);
@@ -413 +472 @@
             {
               cpower = F[i]*G[j];
-              cff = n_Copy(p_GetCoeff(MATELEM(r->nc->COM,j,i),r),r);
+              cff = n_Copy(p_GetCoeff(MATELEM(r->GetNC()->COM,j,i),r),r);
               nPower(cff,cpower,&tmp_num);
               cff = nMult(totcff,tmp_num);
@@ -443 +502 @@
     /* g is univariate monomial */
   {
-    /*    if (ri->nc->type==nc_skew) -- postpone to TU */
+    /*    if (ri->GetNC()->type==nc_skew) -- postpone to TU */
     out = gnc_mm_Mult_uu(F,jG,G[jG],r);
     freeT(F,rN);
@@ -627 +686 @@
   /* Now: F is mono with >=2 exponents, jG<iF */
   /* check the quasi-commutative case */
-//   matrix LCOM=r->nc->COM;
+//   matrix LCOM=r->GetNC()->COM;
 //   number rescoef=n_Init(1,r);
 //   number tmpcoef=n_Init(1,r);
@@ -826 +885 @@
   int k,m;
   int rN=r->N;
-  matrix cMT=r->nc->MT[UPMATELEM(j,i,rN)];         /* cMT=current MT */
+  matrix cMT=r->GetNC()->MT[UPMATELEM(j,i,rN)];         /* cMT=current MT */
 
   poly x=pOne();p_SetExp(x,j,1,r);p_Setm(x,r);
@@ -897 +956 @@
   /*  if ((a==0)||(b==0)||(i<=j)) return(out); */
 
-  if (MATELEM(r->nc->COM,j,i)!=NULL)
+  if (MATELEM(r->GetNC()->COM,j,i)!=NULL)
     /* commutative or quasicommutative case */
   {
@@ -903 +962 @@
     p_AddExp(out,j,b,r);
     p_Setm(out,r);
-    if (r->cf->nIsOne(p_GetCoeff(MATELEM(r->nc->COM,j,i),r))) /* commutative case */
+    if (r->cf->nIsOne(p_GetCoeff(MATELEM(r->GetNC()->COM,j,i),r))) /* commutative case */
     {
       return(out);
@@ -909 +968 @@
     else
     {
-      number tmp_number=p_GetCoeff(MATELEM(r->nc->COM,j,i),r); /* quasicommutative case */
+      number tmp_number=p_GetCoeff(MATELEM(r->GetNC()->COM,j,i),r); /* quasicommutative case */
       nPower(tmp_number,a*b,&tmp_number);
       p_SetCoeff(out,tmp_number,r);
@@ -922 +981 @@
   int rN=r->N;
   int vik = UPMATELEM(j,i,rN);
-  int cMTsize=r->nc->MTsize[vik];
+  int cMTsize=r->GetNC()->MTsize[vik];
   int newcMTsize=0;
   newcMTsize=si_max(a,b);
@@ -928 +987 @@
   if (newcMTsize<=cMTsize)
   {
-    out =  nc_p_CopyGet(MATELEM(r->nc->MT[vik],a,b),r);
+    out =  nc_p_CopyGet(MATELEM(r->GetNC()->MT[vik],a,b),r);
     if (out !=NULL) return (out);
   }
@@ -944 +1003 @@
       for (m=1;m<=cMTsize;m++)
       {
-    out = MATELEM(r->nc->MT[UPMATELEM(j,i,rN)],k,m);
+    out = MATELEM(r->GetNC()->MT[UPMATELEM(j,i,rN)],k,m);
         if ( out != NULL )
         {
-          MATELEM(tmp,k,m) = out;/*MATELEM(r->nc->MT[UPMATELEM(j,i,rN)],k,m)*/
+          MATELEM(tmp,k,m) = out;/*MATELEM(r->GetNC()->MT[UPMATELEM(j,i,rN)],k,m)*/
           //           omCheckAddr(tmp->m);
-          MATELEM(r->nc->MT[UPMATELEM(j,i,rN)],k,m)=NULL;
-          //           omCheckAddr(r->nc->MT[UPMATELEM(j,i,rN)]->m);
+          MATELEM(r->GetNC()->MT[UPMATELEM(j,i,rN)],k,m)=NULL;
+          //           omCheckAddr(r->GetNC()->MT[UPMATELEM(j,i,rN)]->m);
         }
       }
     }
-    id_Delete((ideal *)&(r->nc->MT[UPMATELEM(j,i,rN)]),r);
-    r->nc->MT[UPMATELEM(j,i,rN)] = tmp;
+    id_Delete((ideal *)&(r->GetNC()->MT[UPMATELEM(j,i,rN)]),r);
+    r->GetNC()->MT[UPMATELEM(j,i,rN)] = tmp;
     tmp=NULL;
-    r->nc->MTsize[UPMATELEM(j,i,rN)] = newcMTsize;
+    r->GetNC()->MTsize[UPMATELEM(j,i,rN)] = newcMTsize;
   }
   /* The update of multiplication matrix is finished */
@@ -971 +1030 @@
   int k,m;
   int rN=r->N;
-  matrix cMT=r->nc->MT[UPMATELEM(j,i,rN)];         /* cMT=current MT */
+  matrix cMT=r->GetNC()->MT[UPMATELEM(j,i,rN)];         /* cMT=current MT */
 
   poly x=pOne();p_SetExp(x,j,1,r);p_Setm(x,r);/* var(j); */
@@ -1166 +1225 @@
 poly gnc_ReduceSpolyOld(const poly p1, poly p2/*,poly spNoether*/, const ring r)
 {
+  assume(p_LmDivisibleBy(p1, p2, r));
+
   if (p_GetComp(p1,r)!=p_GetComp(p2,r)
   && (p_GetComp(p1,r)!=0)
@@ -1217 +1278 @@
 poly gnc_ReduceSpolyNew(const poly p1, poly p2, const ring r)
 {
+  assume(p_LmDivisibleBy(p1, p2, r));
+
   const long lCompP1 = p_GetComp(p1,r);
   const long lCompP2 = p_GetComp(p2,r);
@@ -1365 +1428 @@
 poly gnc_CreateSpolyNew(poly p1, poly p2/*,poly spNoether*/, const ring r)
 {
+  assume(r == currRing);
+
+#ifdef PDEBUG
+  pTest(p1);
+  pTest(p2);
+#if MYTEST
+  Print("p1: "); pWrite(p1);
+  Print("p2: "); pWrite(p2);
+#endif
+#endif
+  
   const long lCompP1 = p_GetComp(p1,r);
   const long lCompP2 = p_GetComp(p2,r);
@@ -1376 +1450 @@
   }
 
-//   if ((r->nc->type==nc_lie) && pHasNotCF(p1,p2)) /* prod crit */
+#ifdef PDEBUG
+  if (lCompP1!=lCompP2)
+  {
+    WarnS("gnc_CreateSpolyNew: vector & poly in SPoly!");
+  }
+#endif
+  
+  
+//   if ((r->GetNC()->type==nc_lie) && pHasNotCF(p1,p2)) /* prod crit */
 //   {
 //     return(nc_p_Bracket_qq(pCopy(p2),p1));
 //   }
 
-  poly pL=pOne();
-
-  poly m1=pOne();
-  poly m2=pOne();
-
-  pLcm(p1,p2,pL);                               // pL = lcm( lm(p1), lm(p2) )
-
-  p_Setm(pL,r);
+//  poly pL=p_ISet(1, r);
+
+  poly m1=p_ISet(1, r);
+  poly m2=p_ISet(1, r);
+
+  poly pL = p_Lcm(p1,p2,r);                               // pL = lcm( lm(p1), lm(p2) )
+
+//  p_Setm(pL,r);
 
 #ifdef PDEBUG
@@ -1394 +1476 @@
 #endif
 
-  p_ExpVectorDiff(m1,pL,p1,r);                  // m1 = pL / lm(p1)
+  p_ExpVectorDiff(m1, pL, p1, r);                  // m1 = pL / lm(p1)
   //p_SetComp(m1,0,r);
   //p_Setm(m1,r);
+
 #ifdef PDEBUG
   p_Test(m1,r);
 #endif
-
-  p_ExpVectorDiff(m2,pL,p2,r);                  // m2 = pL / lm(p2)
+//  assume(p_GetComp(m1,r) == 0);
+
+  p_ExpVectorDiff(m2, pL, p2, r);                  // m2 = pL / lm(p2)
 
   //p_SetComp(m2,0,r);
@@ -1408 +1492 @@
   p_Test(m2,r);
 #endif
+
+#ifdef PDEBUG
+#if MYTEST
+  Print("m1: "); pWrite(m1);
+  Print("m2: "); pWrite(m2);
+#endif
+#endif
+
+  
+//  assume(p_GetComp(m2,r) == 0);
+
+#ifdef PDEBUG
+#if 0  
+  if(  (p_GetComp(m2,r) != 0) || (p_GetComp(m1,r) != 0) )
+  {
+    WarnS("gnc_CreateSpolyNew: wrong monomials!");
+    
+    
+#ifdef RDEBUG
+    PrintS("m1 = "); p_Write(m1, r);
+    pDebugPrintR(m1, r);
+    
+    PrintS("m2 = "); p_Write(m2, r);
+    pDebugPrintR(m2, r);
+
+    PrintS("p1 = "); p_Write(p1, r);
+    pDebugPrintR(p1, r);
+
+    PrintS("p2 = "); p_Write(p2, r);
+    pDebugPrintR(p2, r);
+
+    PrintS("pL = "); p_Write(pL, r);
+    pDebugPrintR(pL, r);
+#endif
+    
+  }
+  
+#endif
+#endif
+  
+
 
   p_Delete(&pL,r);
@@ -1415 +1540 @@
   poly M2    = nc_mm_Mult_p(m2,p_Head(p2,r),r); // M2 = m2 * lt(p2)
 
+#ifdef PDEBUG
+  p_Test(M1,r);
+  p_Test(M2,r);
+
+#if MYTEST
+  Print("M1: "); pWrite(M1);
+  Print("M2: "); pWrite(M2);
+#endif
+#endif
+  
   if(M1 == NULL || M2 == NULL)
   {
@@ -1459 +1594 @@
 //   {
   M1=p_Mult_nn(M1,C2,r);                           // M1 = (C2*lc(p1)) * (lcm(lm(p1),lm(p2)) / lm(p1)) * lm(p1)
+
+#ifdef PDEBUG
+  p_Test(M1,r);
+#endif
+
   M2=p_Mult_nn(M2,C1,r);                           // M2 =(-C1*lc(p2)) * (lcm(lm(p1),lm(p2)) / lm(p2)) * lm(p2)
+
+
+  
+#ifdef PDEBUG
+  p_Test(M2,r);
+
+#if MYTEST
+  Print("M1: "); pWrite(M1);
+  Print("M2: "); pWrite(M2);
+#endif
+#endif
+
+#endif
+
   M2=p_Add_q(M1,M2,r);                             // M1 is killed, M2 = spoly(lt(p1), lt(p2)) = C2*M1 - C1*M2
-                                                   // M2 == 0 for supercommutative algebras!
+
+#ifdef PDEBUG
+  p_Test(M2,r);
+
+#if MYTEST
+  Print("M2: "); pWrite(M2);
+#endif
+
+#endif
+
+// M2 == 0 for supercommutative algebras!
 //   }
 //   n_Delete(&MinusOne,r);
@@ -1468 +1632 @@
   p_SetCoeff(m2,C1,r);                           // lc(m2) = C1!!!
 
-
-  poly tmp=p_Copy(p1,r);                         // tmp = p1
-  tmp=p_LmDeleteAndNext(tmp,r);                  // tmp = tail(p1)
-  M1 = nc_mm_Mult_p(m1,tmp,r);                      // M1 = m1 * tail(p1), delete tmp
-  tmp=p_Copy(p2,r);                              // tmp = p2
-  tmp=p_LmDeleteAndNext(tmp,r);                  // tmp = tail(p2)
+#ifdef PDEBUG
+  p_Test(m1,r);
+  p_Test(m2,r);
+#endif
+
+//  poly tmp = p_Copy(p1,r);                         // tmp = p1
+//  tmp=p_LmDeleteAndNext(tmp,r);                  // tmp = tail(p1)
+//#ifdef PDEBUG
+//  p_Test(tmp,r);
+//#endif
+  
+  M1 = nc_mm_Mult_pp(m1, pNext(p1), r);                      // M1 = m1 * tail(p1), delete tmp // ???
+
+#ifdef PDEBUG
+  p_Test(M1,r);
+
+#if MYTEST
+  Print("M1: "); pWrite(M1);
+#endif
+
+#endif
+  
   M2=p_Add_q(M2,M1,r);                           // M2 = spoly(lt(p1), lt(p2)) + m1 * tail(p1), delete M1
-  M1 = nc_mm_Mult_p(m2,tmp,r);                      // M1 = m2 * tail(p2), detele tmp
-  M2=p_Add_q(M2,M1,r);                           // M2 = spoly(lt(p1), lt(p2)) + m1 * tail(p1) + m2*tail(p2)
+#ifdef PDEBUG
+  p_Test(M2,r);
+
+#if MYTEST
+  Print("M2: "); pWrite(M2);
+#endif
+
+#endif
+
+//  tmp=p_Copy(p2,r);                              // tmp = p2
+//  tmp=p_LmDeleteAndNext(tmp,r);                  // tmp = tail(p2)
+
+//#ifdef PDEBUG
+//  p_Test(tmp,r);
+//#endif
+
+  M1 = nc_mm_Mult_pp(m2, pNext(p2), r);                      // M1 = m2 * tail(p2), detele tmp
+  
+#ifdef PDEBUG
+  p_Test(M1,r);
+
+#if MYTEST
+  Print("M1: "); pWrite(M1);
+#endif
+
+#endif
+
+  M2 = p_Add_q(M2,M1,r);                           // M2 = spoly(lt(p1), lt(p2)) + m1 * tail(p1) + m2*tail(p2)
+
+#ifdef PDEBUG
+  p_Test(M2,r);
+
+#if MYTEST
+  Print("M2: "); pWrite(M2);
+#endif
+  
+#endif
                                                  // delete M1
 
@@ -1486 +1701 @@
 #endif
 
-  if (M2!=NULL) pCleardenom(M2);
+  if (M2!=NULL) pCleardenom(M2); //?
 //  if (M2!=NULL) pContent(M2);
 
@@ -1542 +1757 @@
 poly nc_CreateShortSpoly(poly p1, poly p2, const ring r)
 {
-  if (p_GetComp(p1,r)!=p_GetComp(p2,r))
-  {
-#ifdef PDEBUG
-    Werror("nc_CreateShortSpoly: exponent mismatch!");
+#ifdef PDEBUG
+  p_Test(p1, r);
+  p_Test(p2, r);
+#endif
+
+  const long lCompP1 = p_GetComp(p1,r);
+  const long lCompP2 = p_GetComp(p2,r);
+
+  if ((lCompP1!=lCompP2) && (lCompP1!=0) && (lCompP2!=0))
+  {
+#ifdef PDEBUG
+    Werror("nc_CreateShortSpoly: exponent mismatch!"); // !!!!
 #endif
     return(NULL);
   }
-  poly m=pOne();
-  pLcm(p1,p2,m);
-  p_Setm(m,r);
+  
+  const poly m = p_Lcm(p1, p2, si_max(lCompP1, lCompP2), r);
+
+  n_Delete(&p_GetCoeff(m, r), r);
+  pSetCoeff0(m, NULL);
+
 #ifdef PDEBUG
   p_Test(m,r);
 #endif
+  
   return(m);
 }
@@ -1602 +1829 @@
 #ifdef PDEBUG
   pTest(p);
-//   Print("p: "); pWrite(p);
+#if MYTEST
+  Print("p: "); pWrite(p);
+#endif
 #endif
 
@@ -1611 +1840 @@
   const poly pLmB = kBucketGetLm(b); // no new copy!
 
-
+  assume( pLmB != NULL );
+  
 #ifdef PDEBUG
   pTest(pLmB);
-//   Print("pLmB: "); pWrite(pLmB);
+
+#if MYTEST
+  Print("pLmB: "); pWrite(pLmB);
+#endif
 #endif
 
@@ -1622 +1855 @@
 #ifdef PDEBUG
   pTest(m);
-#endif
-
-  poly pp = nc_mm_Mult_pp(m,p,currRing);
+#if MYTEST
+  Print("m: "); pWrite(m);
+#endif
+#endif
+
+  poly pp = nc_mm_Mult_pp(m, p, currRing);
   pDelete(&m);
 
-  const number n = pGetCoeff(pp);
+  assume( pp != NULL );
+  const number n = pGetCoeff(pp); // bug!
   number nn;
 
@@ -1749 +1986 @@
 
 
-#define MYTEST 0
-
 inline void nc_PolyPolyRedNew(poly &b, poly p, number *c)
   // reduces b with p, do not delete both
@@ -1864 +2099 @@
   /* returns [p,q], destroys p */
 {
+  
   if (!rIsPluralRing(currRing)) return(NULL);
   if (pComparePolys(p,q)) return(NULL);
@@ -1935 +2171 @@
           /* compute [ x_j^M1[j],x_i^M2[i] ] */
           if (i<j) {nMax=j;  nMin=i;} else {nMax=i;  nMin=j;}
-          if ( (i==j) || ((MATELEM(currRing->nc->COM,nMin,nMax)!=NULL) && nIsOne(pGetCoeff(MATELEM(currRing->nc->C,nMin,nMax))) )) /* not (the same exp. or commuting exps)*/
+          if ( (i==j) || ((MATELEM(currRing->GetNC()->COM,nMin,nMax)!=NULL) && nIsOne(pGetCoeff(MATELEM(currRing->GetNC()->C,nMin,nMax))) )) /* not (the same exp. or commuting exps)*/
           { bres=NULL; }
           else
@@ -2051 +2287 @@
         Print("Reducing p: "); // !
         p_Write(p, currRing);
-
         Print("With q: "); // !
         p_Write(q, currRing);
@@ -2203 +2438 @@
   /* i<j */
   int rN=r->N;
-  int size=r->nc->MTsize[UPMATELEM(i,j,rN)];
-  matrix M = r->nc->MT[UPMATELEM(i,j,rN)];
+  int size=r->GetNC()->MTsize[UPMATELEM(i,j,rN)];
+  matrix M = r->GetNC()->MT[UPMATELEM(i,j,rN)];
   /*  return(M); */
   int sizeofres;
@@ -2258 +2493 @@
 }
 
-void ncKill(ring r)
-  /* kills the nc extension of ring r */
-{
+void ncKill(ring r) 
+// kills the nc extension of ring r
+{
+  if (r->GetNC()->ref >= 1) /* in use by somebody else */
+  {
+    r->GetNC()->ref--;
+    r->GetNC() = NULL; // don't cleanup, just dereference
+    return;
+  }
+  /* otherwise kill the previous nc data */
+
+  assume( r->GetNC()->ref == 0 );
+
   int i,j;
   int rN=r->N;
@@ -2269 +2514 @@
       for(j=i+1;j<=rN;j++)
       {
-        id_Delete((ideal *)&(r->nc->MT[UPMATELEM(i,j,rN)]),r->nc->basering);
+        id_Delete((ideal *)&(r->GetNC()->MT[UPMATELEM(i,j,rN)]),r->GetNC()->basering);
       }
     }
-    omFreeSize((ADDRESS)r->nc->MT,rN*(rN-1)/2*sizeof(matrix));
-    omFreeSize((ADDRESS)r->nc->MTsize,rN*(rN-1)/2*sizeof(int));
-    id_Delete((ideal *)&(r->nc->COM),r->nc->basering);
-  }
-  id_Delete((ideal *)&(r->nc->C),r->nc->basering);
-  id_Delete((ideal *)&(r->nc->D),r->nc->basering);
-
-  if( rIsSCA(r) && (r->nc->SCAQuotient() != NULL) )
-  {
-    id_Delete(&r->nc->SCAQuotient(), r->nc->basering);
-  }
-
-  r->nc->basering->ref--;
-
-  if ((r->nc->basering->ref<=0)&&(r->nc->basering->nc==NULL))
-  {
-    rKill(r->nc->basering);
+    omFreeSize((ADDRESS)r->GetNC()->MT,rN*(rN-1)/2*sizeof(matrix));
+    omFreeSize((ADDRESS)r->GetNC()->MTsize,rN*(rN-1)/2*sizeof(int));
+    id_Delete((ideal *)&(r->GetNC()->COM),r->GetNC()->basering);
+  }
+  id_Delete((ideal *)&(r->GetNC()->C),r->GetNC()->basering);
+  id_Delete((ideal *)&(r->GetNC()->D),r->GetNC()->basering);
+
+  if( rIsSCA(r) && (r->GetNC()->SCAQuotient() != NULL) )
+  {
+    id_Delete(&r->GetNC()->SCAQuotient(), r->GetNC()->basering);
+  }
+
+  r->GetNC()->basering->ref--;
+
+  if ((r->GetNC()->basering->ref<=0)&&(r->GetNC()->basering->GetNC()==NULL))
+  {
+    rKill(r->GetNC()->basering);
   }
 
@@ -2294 +2539 @@
 }
 
-void ncCleanUp(ring r)
-{
-  /* small CleanUp of r->nc */
-  omFreeSize((ADDRESS)r->nc,sizeof(nc_struct));
-  r->nc = NULL;
-}
+inline void ncCleanUp(nc_struct* p)
+{
+  assume(p != NULL);
+  omFreeSize((ADDRESS)p,sizeof(nc_struct));
+}
+
+inline void ncCleanUp(ring r)
+{
+  /* small CleanUp of r->GetNC() */
+  assume(r != NULL);
+  ncCleanUp(r->GetNC());
+  r->GetNC() = NULL;
+}
+
+// inline 
+void nc_rCopy0(ring res, const ring r)
+{
+  assume(rIsPluralRing(r));
+  assume( res != r );
+
+  res->GetNC() = r->GetNC();
+  res->GetNC()->ref++;
+  nc_p_ProcsSet(res, res->p_Procs);  
+}
+
+
 
 poly nc_p_CopyGet(poly a, const ring r)
 /* for use in getting the mult. matrix elements*/
 /* ring r must be a currRing! */
-/* for consistency, copies a poly from the comm. r->nc->basering */
+/* for consistency, copies a poly from the comm. r->GetNC()->basering */
 /* to its image in NC ring */
 {
@@ -2315 +2580 @@
   }
   if (!rIsPluralRing(r)) return(p_Copy(a,r));
-  if (r==r->nc->basering) return(p_Copy(a,r));
+  if (r==r->GetNC()->basering) return(p_Copy(a,r));
   else
   {
-    return(prCopyR_NoSort(a,r->nc->basering,r));
+    return(prCopyR_NoSort(a,r->GetNC()->basering,r));
   }
 }
@@ -2326 +2591 @@
 /* ring r must be a currRing! */
 /* for consistency, puts a polynomial from the NC ring */
-/* to its presentation in the comm. r->nc->basering */
+/* to its presentation in the comm. r->GetNC()->basering */
 {
   if (r != currRing)
@@ -2337 +2602 @@
 
   if (!rIsPluralRing(r)) return(p_Copy(a,r));
-  if (r==r->nc->basering) return(p_Copy(a,r));
+  if (r==r->GetNC()->basering) return(p_Copy(a,r));
   else
   {
-    return(prCopyR_NoSort(a,r,r->nc->basering));
+    return(prCopyR_NoSort(a,r,r->GetNC()->basering));
   }
 }
@@ -2372 +2637 @@
     if (ExpVar[j]==0)
     {
-      test = nc_p_CopyGet(MATELEM(r->nc->D,i,j),r);
+      test = nc_p_CopyGet(MATELEM(r->GetNC()->D,i,j),r);
       while (test!=NULL)
       {
@@ -2399 +2664 @@
 }
 
-BOOLEAN nc_CheckOrdCondition(matrix D, ring r)
+
+BOOLEAN gnc_CheckOrdCondition(matrix D, ring r)
 /* returns TRUE if there were errors */
 /* checks whether the current ordering */
-/* is admissible for r and D == r->nc->D */
+/* is admissible for r and D == r->GetNC()->D */
 /* to be executed in a currRing */
 {
@@ -2450 +2716 @@
 
 
-BOOLEAN nc_CallPlural(matrix CCC, matrix DDD, poly CCN, poly DDN, ring r)
+BOOLEAN nc_CallPlural(
+                      matrix CCC, matrix DDD,
+                      poly CCN, poly DDN,
+                      ring r, 
+                      bool bSetupQuotient, bool bCopyInput, bool bBeQuiet,
+                      ring curr)
   /* returns TRUE if there were errors */
   /* analyze inputs, check them for consistency */
   /* detects nc_type, DO NOT initialize multiplication but call for it at the end*/
   /* checks the ordering condition and evtl. NDC */
-// NOTE: all the data are READ_ONLY from the currRing, we change r,
-// which is a DIFFERENT ring, but has the same representation!
-{
-
+// NOTE: all the data belong to the curr,
+// we change r which may be the same ring, and must have the same representation!
+{
+//  assume( curr != r );
+  assume( rSamePolyRep(r, curr) );
+
+
+  if( r->N == 1 ) // clearly commutative!!!
+  {
+    assume(
+           ( (CCC != NULL) && (MATCOLS(CCC) == 1) && (MATROWS(CCC) == 1) && (MATELEM(CCC,1,1) == NULL) ) ||
+           ( (CCN == NULL) )
+          );
+    
+    assume(
+           ( (DDD != NULL) && (MATCOLS(DDD) == 1) && (MATROWS(DDD) == 1) && (MATELEM(DDD,1,1) == NULL) ) ||
+           ( (DDN == NULL) )
+          );
+           
+
+  }
+
+  
+  // there must be:
+  assume( (CCC != NULL) != (CCN != NULL) ); // exactly one data about coeffs (C).
+  assume( !((DDD != NULL) && (DDN != NULL)) ); // at most one data about tails (D).
+  
+  ring save = currRing;
+
+  if( save != curr )
+    rChangeCurrRing(curr);
+
+#if OUTPUT
+  if( CCC != NULL )
+  {
+    PrintS("nc_CallPlural(), Input data, CCC: \n");    
+    iiWriteMatrix(CCC, "C", 2, 4);
+  }
+  if( DDD != NULL )
+  {
+    PrintS("nc_CallPlural(), Input data, DDD: \n");  
+    iiWriteMatrix(DDD, "D", 2, 4);
+  }
+#endif
+
+  
 #ifndef NDEBUG
   idTest((ideal)CCC);
@@ -2466 +2779 @@
 #endif
 
-  matrix CC = NULL;
-  matrix DD = NULL;
-  poly CN = NULL;
-  poly DN = NULL;
-  matrix C;
-  matrix D;
-  number nN,pN,qN;
-  int tmpIsSkewConstant;
-  int i,j;
-
-
-  if (r->nc != NULL)
-  {
-    WarnS("redefining algebra structure");
-    if (r->nc->ref>1) /* in use by somebody else */
-    {
-      r->nc->ref--;
-    }
-    else  /* kill the previous nc data */
-    {
-      ncKill(r);
-    }
-  }
-  ring save = currRing;
-
-  assume(currRing!=r);
-  assume( rSamePolyRep(r, currRing) );
-  rChangeCurrRing(r);
-
-  r->nc = (nc_struct *)omAlloc0(sizeof(nc_struct));
-  r->nc->ref = 1;
-  r->nc->basering = r; // !?
-  r->ref++;
-  ncRingType(r, nc_undef);
+  if( (!bBeQuiet) && (r->GetNC() != NULL) )
+    WarnS("going to redefine the algebra structure");
+  
+  if( currRing != r )
+    rChangeCurrRing(r);
 
 #ifndef NDEBUG
@@ -2508 +2792 @@
 #endif
 
-  // there must be:
-  assume( (CCC != NULL) != (CCN != NULL) ); // exactly one data about coeffs (C).
-  assume( !((DDD != NULL) && (DDN != NULL)) ); // at most one data about tails (D).
-
-  /* initialition of the matrix C */
-  /* check the correctness of arguments */
-
+  matrix CC = NULL;
+  poly CN = NULL;
+  matrix C; bool bCnew = false;
+
+  matrix DD = NULL;
+  poly DN = NULL;
+  matrix D; bool bDnew = false;
+
+  number nN, pN, qN;
+
+  bool IsSkewConstant = false, tmpIsSkewConstant;
+  int i, j;
+
+  nc_type nctype = nc_undef;
+  
+  //////////////////////////////////////////////////////////////////
+  // check the correctness of arguments, without any real chagnes!!!
+
+  
+
+  // check C
   if ((CCC != NULL) && ( (MATCOLS(CCC)==1) || MATROWS(CCC)==1 ) )
   {
@@ -2523 +2821 @@
     if ((CCC != NULL) && ( (MATCOLS(CCC)!=r->N) || (MATROWS(CCC)!=r->N) ))
     {
-      Werror("Square %d x %d  matrix expected",r->N,r->N);
-      ncCleanUp(r);
-      rChangeCurrRing(save);
+      Werror("Square %d x %d  matrix expected", r->N, r->N);
+
+      if( currRing != save )
+        rChangeCurrRing(save);
       return TRUE;
     }
@@ -2532 +2831 @@
   if (( CCN != NULL) && (CN == NULL)) CN = CCN;
 
-  /* initialition of the matrix D */
-  /* check the correctness of arguments */
-
+  // check D
   if ((DDD != NULL) && ( (MATCOLS(DDD)==1) || MATROWS(DDD)==1 ) )
   {
@@ -2544 +2841 @@
     {
       Werror("Square %d x %d  matrix expected",r->N,r->N);
-      ncCleanUp(r);
-      rChangeCurrRing(save);
+
+      if( currRing != save )
+        rChangeCurrRing(save);
       return TRUE;
     }
   }
+
   if (( DDD != NULL) && (DD == NULL)) DD = DDD; // mpCopy(DDD); // ???
   if (( DDN != NULL) && (DN == NULL)) DN = DDN;
 
-  /* further checks */
-
-  // all data in 'save'!
-
+  // further checks and some analysis:
+  // all data in 'curr'!
   if (CN != NULL)       /* create matrix C = CN * Id */
   {
-    nN = p_GetCoeff(CN,save);
-    if (n_IsZero(nN,save))
+    nN = p_GetCoeff(CN, curr);
+    if (n_IsZero(nN, curr))
     {
       Werror("Incorrect input : zero coefficients are not allowed");
-      ncCleanUp(r);
-      rChangeCurrRing(save);
+
+      if( currRing != save )
+        rChangeCurrRing(save);
       return TRUE;
     }
-    if (n_IsOne(nN, save))
-    {
-      ncRingType(r, nc_lie);
-    }
+
+    if (n_IsOne(nN, curr))
+      nctype = nc_lie;
     else
-    {
-      ncRingType(r, nc_general);
-    }
-    r->nc->IsSkewConstant = 1;
+      nctype = nc_general;
+
+    IsSkewConstant = true;
+
     C = mpNew(r->N,r->N); // ring independent!
+    bCnew = true;
+
     for(i=1; i<r->N; i++)
-    {
+      for(j=i+1; j<=r->N; j++)
+        MATELEM(C,i,j) = prCopyR_NoSort(CN, curr, r); // nc_p_CopyPut(CN, r); // copy CN from curr into r
+  } else
+  if ( (CN == NULL) && (CC != NULL) ) /* copy matrix C */
+  {
+    /* analyze C */
+
+    pN = NULL; /* check the consistency later */
+
+    if( r->N > 1 )
+      if ( MATELEM(CC,1,2) != NULL )
+        pN = p_GetCoeff(MATELEM(CC,1,2), curr);
+
+    tmpIsSkewConstant = true;
+
+    for(i=1; i<r->N; i++)
       for(j=i+1; j<=r->N; j++)
       {
-        MATELEM(C,i,j) = nc_p_CopyPut(CN, r); // copy CN from r into r->nc->basering
-      }
-    }
-  }
-  if ( (CN == NULL) && (CC != NULL) ) /* copy matrix C */
-  {
-    C = mpCopy(CC);
-    /* analyze C */
-    if ( MATELEM(C,1,2) == NULL )
-      pN = NULL; /* check the consistency later */
-    else
-      pN = p_GetCoeff(MATELEM(C,1,2),r);
-    tmpIsSkewConstant = 1;
-    for(i=1; i<r->N; i++)
-    {
-      for(j=i+1; j<=r->N; j++)
-      {
-        if (MATELEM(C,i,j) == NULL)
+        if (MATELEM(CC,i,j) == NULL)
           qN = NULL;
         else
-          qN = p_GetCoeff(MATELEM(C,i,j),r);
+          qN = p_GetCoeff(MATELEM(CC,i,j),curr);
 
         if ( qN == NULL )   /* check the consistency: Cij!=0 */
-          // find also illegal pN
+        // find also illegal pN
         {
           Werror("Incorrect input : matrix of coefficients contains zeros in the upper triangle");
-          ncCleanUp(r);
-          rChangeCurrRing(save);
+
+        if( currRing != save )
+            rChangeCurrRing(save);
           return TRUE;
         }
-        if (!n_Equal(pN,qN, r)) tmpIsSkewConstant = 0;
+
+        if (!n_Equal(pN, qN, curr)) tmpIsSkewConstant = false;
       }
-    }
-    r->nc->IsSkewConstant=tmpIsSkewConstant;
-    if ( (tmpIsSkewConstant) && (nIsOne(pN)) )
-    {
-      ncRingType(r, nc_lie);
+
+    if( bCopyInput )
+    {
+      C = mpCopy(CC, curr, r); // Copy C into r!!!???
+      bCnew = true;
     }
     else
-    {
-      ncRingType(r, nc_general);
-    }
+      C = CC;
+
+    IsSkewConstant = tmpIsSkewConstant;
+
+    if ( tmpIsSkewConstant && n_IsOne(pN, curr) )
+      nctype = nc_lie;
+    else
+      nctype = nc_general;
   }
 
   /* initialition of the matrix D */
-  if ( DD == NULL )
-    /* we treat DN only (it could also be NULL) */
-  {
-    D = mpNew(r->N,r->N);
+  if ( DD == NULL ) /* we treat DN only (it could also be NULL) */
+  {
+    D = mpNew(r->N,r->N); bDnew = true;
+
     if (DN  == NULL)
     {
-      if ( (ncRingType(r) == nc_lie) || (ncRingType(r) == nc_undef) )
+      if ( (nctype == nc_lie) || (nctype == nc_undef) )
+        nctype = nc_comm; /* it was nc_skew earlier */
+      else /* nc_general, nc_skew */
+        nctype = nc_skew;
+    }
+    else /* DN  != NULL */
+      for(i=1; i<r->N; i++)
+        for(j=i+1; j<=r->N; j++)
+          MATELEM(D,i,j) = prCopyR_NoSort(DN, curr, r); // project DN into r->GetNC()->basering!
+  }
+  else /* DD != NULL */
+  {
+    bool b = true; // DD == null ?
+    
+    for(int i = 1; (i < r->N) && b; i++)
+    for(int j = i+1; (j <= r->N) && b; j++)
+      if (MATELEM(DD, i, j) != NULL)
       {
-        ncRingType(r, nc_comm); /* it was nc_skew earlier */
+        b = false;
+        break;
       }
+
+    if (b) // D == NULL!!!
+    {
+      if ( (nctype == nc_lie) || (nctype == nc_undef) )
+        nctype = nc_comm; /* it was nc_skew earlier */
       else /* nc_general, nc_skew */
-      {
-        ncRingType(r, nc_skew);
-      }
-    }
-    else /* DN  != NULL */
-    {
-      for(i=1; i<r->N; i++)
-      {
-        for(j=i+1; j<=r->N; j++)
-        {
-          MATELEM(D,i,j) = nc_p_CopyPut(DN,r); // project DN into r->nc->basering!
-        }
-      }
-    }
-  }
-  else /* DD != NULL */
-  {
-    D = mpCopy(DD); // Copy DD into r!!!
-  }
-  /* analyze D */
-  /* check the ordering condition for D (both matrix and poly cases) */
-
-  if ( nc_CheckOrdCondition(D, r) )
-  {
-    ncCleanUp(r);
+        nctype = nc_skew;
+    }
+    
+    if( bCopyInput )
+    {
+      D = mpCopy(DD, curr, r); // Copy DD into r!!!
+      bDnew = true;
+    }
+    else
+      D = DD;
+
+  }
+
+  assume( C != NULL );
+  assume( D != NULL );
+  
+#if OUTPUT
+  PrintS("nc_CallPlural(), Computed data, C: \n");
+  iiWriteMatrix(C, "C", 2, 4);
+
+  PrintS("nc_CallPlural(), Computed data, D: \n");
+  iiWriteMatrix(D, "D", 2, 4);
+
+  Print("\nTemporary: type = %d, IsSkewConstant = %d\n", nctype, IsSkewConstant);
+#endif
+
+
+
+  
+  // check the ordering condition for D (both matrix and poly cases):
+  if ( gnc_CheckOrdCondition(D, r) )
+  {
+    if( bCnew ) mpDelete( &C, r );
+    if( bDnew ) mpDelete( &D, r );
+
+    Werror("Matrix of polynomials violates the ordering condition");
+
+    if( currRing != save )
+      rChangeCurrRing(save);
+    return TRUE;
+  }
+
+  // okay now we are ready for this!!!
+
+  // create new non-commutative structure
+  nc_struct *nc_new = (nc_struct *)omAlloc0(sizeof(nc_struct));
+
+  ncRingType(nc_new) = nctype;
+
+  nc_new->C = C; // if C and D were given by matrices at the beginning they are in r
+  nc_new->D = D; // otherwise they should be in r->GetNC()->basering(polynomial * Id_{N})
+
+  nc_new->IsSkewConstant = (IsSkewConstant?1:0);
+
+  nc_new->ref = 1;
+  nc_new->basering = r; // !?
+
+  // Setup new NC structure!!!
+  if (r->GetNC() != NULL)
+    ncKill(r);
+
+  r->ref++; // ?
+  r->GetNC() = nc_new;
+
+  if( currRing != save )
     rChangeCurrRing(save);
-    Werror("Matrix of polynomials violates the ordering condition");
-    return TRUE;
-  }
-  r->nc->C = C; // if C and D were given by matrices at the beginning they are in r
-  r->nc->D = D; // otherwise they should be in r->nc->basering(polynomial * Id_{N})
-
-  rChangeCurrRing(save);
-
-  return nc_InitMultiplication(r);
+
+  return gnc_InitMultiplication(r, bSetupQuotient);
 }
 
 //////////////////////////////////////////////////////////////////////////////
-BOOLEAN nc_InitMultiplication(ring r)
+BOOLEAN gnc_InitMultiplication(ring r, bool bSetupQuotient)
 {
   /* returns TRUE if there were errors */
   /* initialize the multiplication: */
-  /*  r->nc->MTsize, r->nc->MT, r->nc->COM, */
-  /* and r->nc->IsSkewConstant for the skew case */
+  /*  r->GetNC()->MTsize, r->GetNC()->MT, r->GetNC()->COM, */
+  /* and r->GetNC()->IsSkewConstant for the skew case */
   if (rVar(r)==1)
   {
     ncRingType(r, nc_comm);
-    r->nc->IsSkewConstant=1;
+    r->GetNC()->IsSkewConstant=1;
     return FALSE;
   }
+
   ring save = currRing;
+
   int WeChangeRing = 0;
   if (currRing!=r)
@@ -2693 +3054 @@
     WeChangeRing = 1;
   }
-  assume( (currRing == r->nc->basering)
-       || ((currRing->nc!=NULL) && (currRing->nc->basering==r->nc->basering)) );   // otherwise we cannot work with all these matrices!
+  assume( (currRing == r->GetNC()->basering)
+       || ((currRing->GetNC()!=NULL) && (currRing->GetNC()->basering==r->GetNC()->basering)) );   // otherwise we cannot work with all these matrices!
 
   int i,j;
-  r->nc->MT = (matrix *)omAlloc0((r->N*(r->N-1))/2*sizeof(matrix));
-  r->nc->MTsize = (int *)omAlloc0((r->N*(r->N-1))/2*sizeof(int));
-  idTest(((ideal)r->nc->C));
-  matrix COM = mpCopy(r->nc->C);
+  r->GetNC()->MT = (matrix *)omAlloc0((r->N*(r->N-1))/2*sizeof(matrix));
+  r->GetNC()->MTsize = (int *)omAlloc0((r->N*(r->N-1))/2*sizeof(int));
+  idTest(((ideal)r->GetNC()->C));
+  matrix COM = mpCopy(r->GetNC()->C);
   poly p,q;
   short DefMTsize=7;
@@ -2710 +3071 @@
     for(j=i+1; j<=r->N; j++)
     {
-      if ( MATELEM(r->nc->D,i,j) == NULL ) /* quasicommutative case */
+      if ( MATELEM(r->GetNC()->D,i,j) == NULL ) /* quasicommutative case */
       {
         /* 1x1 mult.matrix */
-        r->nc->MTsize[UPMATELEM(i,j,r->N)] = 1;
-        r->nc->MT[UPMATELEM(i,j,r->N)] = mpNew(1,1);
+        r->GetNC()->MTsize[UPMATELEM(i,j,r->N)] = 1;
+        r->GetNC()->MT[UPMATELEM(i,j,r->N)] = mpNew(1,1);
       }
       else /* pure noncommutative case */
@@ -2722 +3083 @@
         p_Delete(&(MATELEM(COM,i,j)),r);
         //MATELEM(COM,i,j) = NULL; // done by p_Delete
-        r->nc->MTsize[UPMATELEM(i,j,r->N)] = DefMTsize; /* default sizes */
-        r->nc->MT[UPMATELEM(i,j,r->N)] = mpNew(DefMTsize, DefMTsize);
+        r->GetNC()->MTsize[UPMATELEM(i,j,r->N)] = DefMTsize; /* default sizes */
+        r->GetNC()->MT[UPMATELEM(i,j,r->N)] = mpNew(DefMTsize, DefMTsize);
       }
       /* set MT[i,j,1,1] to c_i_j*x_i*x_j + D_i_j */
       p = p_ISet(1,r); /* instead of     p = pOne(); */
-      if (MATELEM(r->nc->C,i,j)!=NULL)
-        p_SetCoeff(p,n_Copy(pGetCoeff(MATELEM(r->nc->C,i,j)),r),r);
+      if (MATELEM(r->GetNC()->C,i,j)!=NULL)
+        p_SetCoeff(p,n_Copy(pGetCoeff(MATELEM(r->GetNC()->C,i,j)),r),r);
       p_SetExp(p,i,1,r);
       p_SetExp(p,j,1,r);
       p_Setm(p,r);
-      p_Test(MATELEM(r->nc->D,i,j),r->nc->basering);
-      q =  nc_p_CopyGet(MATELEM(r->nc->D,i,j),r);
+      p_Test(MATELEM(r->GetNC()->D,i,j),r->GetNC()->basering);
+      q =  nc_p_CopyGet(MATELEM(r->GetNC()->D,i,j),r);
       p = p_Add_q(p,q,r);
-      MATELEM(r->nc->MT[UPMATELEM(i,j,r->N)],1,1) = nc_p_CopyPut(p,r);
+      MATELEM(r->GetNC()->MT[UPMATELEM(i,j,r->N)],1,1) = nc_p_CopyPut(p,r);
       p_Delete(&p,r);
       // p = NULL;// done by p_Delete
@@ -2745 +3106 @@
     {
       //      assume(pN!=NULL);
-      //      if ((tmpIsSkewConstant==1) && (nIsOne(pGetCoeff(pN)))) r->nc->type=nc_lie;
-      //      else r->nc->type=nc_general;
+      //      if ((tmpIsSkewConstant==1) && (nIsOne(pGetCoeff(pN)))) r->GetNC()->type=nc_lie;
+      //      else r->GetNC()->type=nc_general;
     }
     if (IsNonComm==0)
     {
       ncRingType(r, nc_skew); /* TODO: check whether it is commutative */
-      r->nc->IsSkewConstant=tmpIsSkewConstant;
-    }
-  }
-  r->nc->COM=COM;
-
-  gnc_p_ProcsSet(r, r->p_Procs);
-
-  if (WeChangeRing)
-  {
+      r->GetNC()->IsSkewConstant=tmpIsSkewConstant;
+    }
+  }
+  r->GetNC()->COM=COM;
+
+  nc_p_ProcsSet(r, r->p_Procs);
+
+  if(bSetupQuotient) // Test me!!!
+  {
+    nc_SetupQuotient(r); 
+  }
+
+  if (save != currRing)
     rChangeCurrRing(save);
-  }
+
   return FALSE;
 }
@@ -2768 +3133 @@
 {
   // "commutative"
-  rGR->p_Procs->p_Mult_mm  = gnc_p_Mult_mm;
-  rGR->p_Procs->pp_Mult_mm = gnc_pp_Mult_mm;
-  rGR->p_Procs->p_Minus_mm_Mult_qq = NULL; // gnc_p_Minus_mm_Mult_qq_ign; // should not be used!!!
-
-  p_Procs->p_Mult_mm  = gnc_p_Mult_mm;
-  p_Procs->pp_Mult_mm = gnc_pp_Mult_mm;
-  p_Procs->p_Minus_mm_Mult_qq = NULL; // gnc_p_Minus_mm_Mult_qq_ign; // should not be used!!!
+  p_Procs->p_Mult_mm  = rGR->p_Procs->p_Mult_mm  = gnc_p_Mult_mm;
+  p_Procs->pp_Mult_mm = rGR->p_Procs->pp_Mult_mm = gnc_pp_Mult_mm;
+  p_Procs->p_Minus_mm_Mult_qq = rGR->p_Procs->p_Minus_mm_Mult_qq = NULL;
+  // gnc_p_Minus_mm_Mult_qq_ign; // should not be used!!!???
+
 
 
   // non-commutaitve multiplication by monomial from the left
-  rGR->nc->p_Procs.mm_Mult_p   = gnc_mm_Mult_p;
-  rGR->nc->p_Procs.mm_Mult_pp  = gnc_mm_Mult_pp;
-
-  rGR->nc->p_Procs.GB          = gnc_gr_bba; // bba even for local case!
-
-//   rGR->nc->p_Procs.GlobalGB    = gnc_gr_bba;
-//   rGR->nc->p_Procs.LocalGB     = gnc_gr_mora;
+  rGR->GetNC()->p_Procs.mm_Mult_p   = gnc_mm_Mult_p;
+  rGR->GetNC()->p_Procs.mm_Mult_pp  = gnc_mm_Mult_pp;
+
+  rGR->GetNC()->p_Procs.GB          = gnc_gr_bba; // bba even for local case!
+
+//   rGR->GetNC()->p_Procs.GlobalGB    = gnc_gr_bba;
+//   rGR->GetNC()->p_Procs.LocalGB     = gnc_gr_mora;
 
 
 #if 0
   // Previous Plural's implementation...
-  rGR->nc->p_Procs.SPoly       = gnc_CreateSpolyOld;
-  rGR->nc->p_Procs.ReduceSPoly = gnc_ReduceSpolyOld;
-
-  rGR->nc->p_Procs.BucketPolyRed  = gnc_kBucketPolyRedOld;
-  rGR->nc->p_Procs.BucketPolyRed_Z= gnc_kBucketPolyRed_ZOld;
+  rGR->GetNC()->p_Procs.SPoly       = gnc_CreateSpolyOld;
+  rGR->GetNC()->p_Procs.ReduceSPoly = gnc_ReduceSpolyOld;
+
+  rGR->GetNC()->p_Procs.BucketPolyRed  = gnc_kBucketPolyRedOld;
+  rGR->GetNC()->p_Procs.BucketPolyRed_Z= gnc_kBucketPolyRed_ZOld;
 #else
   // A bit cleaned up and somewhat rewritten functions...
-  rGR->nc->p_Procs.SPoly       = gnc_CreateSpolyNew;
-  rGR->nc->p_Procs.ReduceSPoly = gnc_ReduceSpolyNew;
-
-  rGR->nc->p_Procs.BucketPolyRed  = gnc_kBucketPolyRedNew;
-  rGR->nc->p_Procs.BucketPolyRed_Z= gnc_kBucketPolyRed_ZNew;
+  rGR->GetNC()->p_Procs.SPoly       = gnc_CreateSpolyNew;
+  rGR->GetNC()->p_Procs.ReduceSPoly = gnc_ReduceSpolyNew; 
+
+  rGR->GetNC()->p_Procs.BucketPolyRed  = gnc_kBucketPolyRedNew;
+  rGR->GetNC()->p_Procs.BucketPolyRed_Z= gnc_kBucketPolyRed_ZNew;
 #endif
 
@@ -2817 +3180 @@
     _p_procs->p_Minus_mm_Mult_qq= NULL; // gnc_p_Minus_mm_Mult_qq_ign;
 
-    r->nc->mmMultP()       = gnc_mm_Mult_p;
-    r->nc->mmMultPP()      = gnc_mm_Mult_pp;
-
-    r->nc->GB()            = gnc_gr_bba;
-
-    r->nc->SPoly()         = gnc_CreateSpoly;
-    r->nc->ReduceSPoly()   = gnc_ReduceSpoly;
+    r->GetNC()->mmMultP()       = gnc_mm_Mult_p;
+    r->GetNC()->mmMultPP()      = gnc_mm_Mult_pp;
+
+    r->GetNC()->GB()            = gnc_gr_bba;
+
+    r->GetNC()->SPoly()         = gnc_CreateSpoly;
+    r->GetNC()->ReduceSPoly()   = gnc_ReduceSpoly;
 
 #endif
@@ -3114 +3477 @@
 
 
+// creates a commutative nc extension; "converts" comm.ring to a Plural ring
 ring nc_rCreateNCcomm(ring r)
-  /* creates a commutative nc extension; "converts" comm.ring to a Plural ring */
 {
   if (rIsPluralRing(r)) return r;
-  ring save = currRing;
-  int WeChangeRing = 0;
-  if (currRing!=r)
-  {
-    rChangeCurrRing(r);
-    WeChangeRing = 1;
-  }
-  r->nc = (nc_struct *)omAlloc0(sizeof(nc_struct));
-  r->nc->ref = 1;
-  r->nc->basering = r;
-  ncRingType(r, nc_comm);
-  r->nc->IsSkewConstant = 1;
-
-  // no reference increment to the base commutative ring???
-
-  matrix C = mpNew(r->N,r->N);
+
+  matrix C = mpNew(r->N,r->N); // ring-independent!?!
   matrix D = mpNew(r->N,r->N);
-  int i,j;
-  for(i=1; i<r->N; i++)
-  {
-    for(j=i+1; j<=r->N; j++)
-    {
-      MATELEM(C,i,j) = pOne();
-    }
-  }
-  r->nc->C = C;
-  r->nc->D = D;
-  if (nc_InitMultiplication(r))
-  {
-    WarnS("Error initializing multiplication!");
-  }
-  if (WeChangeRing)
-  {
-    rChangeCurrRing(save);
-  }
+
+  for(int i=1; i<r->N; i++)
+    for(int j=i+1; j<=r->N; j++)
+      MATELEM(C,i,j) = p_ISet(1, r);
+
+  if (nc_CallPlural(C, D, NULL, NULL, r)) // TODO: what about quotient ideal?
+    WarnS("Error initializing multiplication!"); // No reaction!???
+  
   return r;
 }
@@ -3284 +3623 @@
 
 
-#endif
-
 
 // int Commutative_Context(ring r, leftv expression)
@@ -3296 +3633 @@
 // int Comm_Context_Poly(ring r, poly p)
 // {
-//   poly COMM=r->nc->COMM;
+//   poly COMM=r->GetNC()->COMM;
 //   poly pp=pOne();
 //   memset(pp->exp,0,r->ExpL_Size*sizeof(long));

kernel/gring.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: gring.h,v 1.20 2007-02-16 11:07:10 motsak Exp $ */
+/* $Id: gring.h,v 1.21 2008-06-10 10:17:31 motsak Exp $ */
 /*
 * ABSTRACT additional defines etc for --with-plural
@@ -11 +11 @@
 #ifdef HAVE_PLURAL
 
+
 #include <structs.h>
 #include <ring.h>
 
-/* the part, related to the interface */
-BOOLEAN nc_CallPlural(matrix CC, matrix DD, poly CN, poly DN, ring r);
-
-BOOLEAN nc_CheckOrdCondition(matrix D, ring r);
+// the part, related to the interface
+// Changes r, Assumes that all other input belongs to currRing
+BOOLEAN nc_CallPlural(matrix CC, matrix DD, poly CN, poly DN, ring r,
+                      bool bSetupQuotient = false,
+                      bool bCopyInput = true,
+                      bool bBeQuiet = false,
+                      ring curr = currRing);
+
+// BOOLEAN nc_CheckOrdCondition(matrix D, ring r);
+// BOOLEAN nc_CheckOrdCondition(ring r); // with D == r->GetNC()->D
+
 BOOLEAN nc_CheckSubalgebra(poly PolyVar, ring r);
-BOOLEAN nc_InitMultiplication(ring r); // should call nc_p_ProcsSet!
+
+// BOOLEAN nc_InitMultiplication(ring r); // should call nc_p_ProcsSet!
+// NOTE: instead of constructing nc_struct and calling nc_InitMultiplication yourself - just create C, D and call nc_CallPlural!!!
+
+
 BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate);
 
@@ -29 +41 @@
 // this function should be used inside QRing definition!
 // we go from rG into factor ring rGR with factor ideal rGR->qideal.
-bool nc_SetupQuotient(ring rGR, const ring rG);
+bool nc_SetupQuotient(ring rGR, const ring rG = NULL); // rG == NULL means that there is no base G-algebra
 
 
@@ -37 +49 @@
 ring nc_rCreateNCcomm(ring r); 
 
-void ncCleanUp(ring r); /* smaller than kill */
-void ncKill(ring r);
-
+void ncCleanUp(nc_struct* p); // just free memory!
+void ncCleanUp(ring r); // smaller than kill: just free mem
+void ncKill(ring r); // complete destructor
+
+BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient = true); // in ring.cc
+
+
+// share the same nc-structure with a new copy ``res'' of ``r''.
+// used by rCopy only.
+// additionally inits multipication on ``res''!
+void nc_rCopy0(ring res, const ring r);
 
 // for p_Minus_mm_Mult_qq in pInline2.h
@@ -90 +110 @@
 
 
+
+// returns the LCM of the head terms of a and b with given component
+poly p_Lcm(const poly a, const poly b, const long lCompM, const ring r);
+
+// returns the LCM of the head terms of a and b with component = max comp. of a & b
+poly p_Lcm(const poly a, const poly b, const ring r);
+
+
+
 // //////////////////////////////////////////////////////////////////////// //
 // NC inlines
 
-
-
-inline void ncRingType(ring r, nc_type t)
-{
-  assume((r != NULL) && (r->nc != NULL));
-  r->nc->type = t;
+inline nc_type& ncRingType(nc_struct* p)
+{
+  assume(p!=NULL);
+  return (p->type);
 };
 
-inline nc_type ncRingType(ring r)
-{
-  assume(rIsPluralRing(r));
-
-  return (r->nc->type);
+inline nc_type& ncRingType(ring r) // get and set
+{
+  assume(rIsPluralRing(r));
+  return (ncRingType(r->GetNC()));
 };
+
+inline void ncRingType(ring r, nc_type t) // Set
+{
+  assume((r != NULL) && (r->GetNC() != NULL));
+  ncRingType(r) = t;
+};
+
+inline nc_struct*& GetNC(ring r)
+{
+  return r->GetNC();
+}; 
 
 
@@ -117 +154 @@
 {
   assume(rIsPluralRing(r));
-  assume(r->nc->p_Procs.mm_Mult_pp!=NULL);
-  return r->nc->p_Procs.mm_Mult_pp(m, p, r);
+  assume(r->GetNC()->p_Procs.mm_Mult_pp!=NULL);
+  return r->GetNC()->p_Procs.mm_Mult_pp(m, p, r);
 //  return pp_Mult_mm( p, m, r);
 }
@@ -127 +164 @@
 {
   assume(rIsPluralRing(r));
-  assume(r->nc->p_Procs.mm_Mult_p!=NULL);
-  return r->nc->p_Procs.mm_Mult_p(m, p, r);
+  assume(r->GetNC()->p_Procs.mm_Mult_p!=NULL);
+  return r->GetNC()->p_Procs.mm_Mult_p(m, p, r);
 //   return p_Mult_mm( p, m, r);
 }
@@ -135 +172 @@
 {
   assume(rIsPluralRing(r));
-  assume(r->nc->p_Procs.SPoly!=NULL);
-  return r->nc->p_Procs.SPoly(p1, p2, r);
+  assume(r->GetNC()->p_Procs.SPoly!=NULL);
+  return r->GetNC()->p_Procs.SPoly(p1, p2, r);
 }
 
@@ -142 +179 @@
 {
   assume(rIsPluralRing(r));
-  assume(r->nc->p_Procs.ReduceSPoly!=NULL);
-  return r->nc->p_Procs.ReduceSPoly(p1, p2, r);
+  assume(r->GetNC()->p_Procs.ReduceSPoly!=NULL);
+#ifdef PDEBUG
+//  assume(p_LmDivisibleBy(p1, p2, r));
+#endif
+  return r->GetNC()->p_Procs.ReduceSPoly(p1, p2, r);
 }
 
@@ -150 +190 @@
 {
   assume(rIsPluralRing(r));
-//  assume(r->nc->p_Procs.PolyReduce!=NULL);
-//  r->nc->p_Procs.PolyReduce(b, p, c, r);
+//  assume(r->GetNC()->p_Procs.PolyReduce!=NULL);
+//  r->GetNC()->p_Procs.PolyReduce(b, p, c, r);
 }
 */
@@ -161 +201 @@
 //   return gnc_kBucketPolyRedNew(b, p, c);
 
-  assume(currRing->nc->p_Procs.BucketPolyRed!=NULL);
-  return currRing->nc->p_Procs.BucketPolyRed(b, p, c);
+  assume(currRing->GetNC()->p_Procs.BucketPolyRed!=NULL);
+  return currRing->GetNC()->p_Procs.BucketPolyRed(b, p, c);
 }
 
@@ -171 +211 @@
 //   return gnc_kBucketPolyRed_ZNew(b, p, c);
 
-  assume(currRing->nc->p_Procs.BucketPolyRed_Z!=NULL);
-  return currRing->nc->p_Procs.BucketPolyRed_Z(b, p, c);
+  assume(currRing->GetNC()->p_Procs.BucketPolyRed_Z!=NULL);
+  return currRing->GetNC()->p_Procs.BucketPolyRed_Z(b, p, c);
 
 }
@@ -180 +220 @@
   assume(rIsPluralRing(currRing));
 
-  assume(currRing->nc->p_Procs.GB!=NULL);
-  return currRing->nc->p_Procs.GB(F, Q, w, hilb, strat);
+  assume(currRing->GetNC()->p_Procs.GB!=NULL);
+  return currRing->GetNC()->p_Procs.GB(F, Q, w, hilb, strat);
 
 /*
   if (pOrdSgn==-1)
   {
-    assume(currRing->nc->p_Procs.LocalGB!=NULL);
-    return currRing->nc->p_Procs.LocalGB(F, Q, w, hilb, strat);
+    assume(currRing->GetNC()->p_Procs.LocalGB!=NULL);
+    return currRing->GetNC()->p_Procs.LocalGB(F, Q, w, hilb, strat);
   } else
   {
-    assume(currRing->nc->p_Procs.GlobalGB!=NULL);
-    return currRing->nc->p_Procs.GlobalGB(F, Q, w, hilb, strat);
+    assume(currRing->GetNC()->p_Procs.GlobalGB!=NULL);
+    return currRing->GetNC()->p_Procs.GlobalGB(F, Q, w, hilb, strat);
   }
 */
@@ -205 +245 @@
 // we need nc_gr_initBba for sca_gr_bba and gr_bba.
 void nc_gr_initBba(ideal F,kStrategy strat); 
+BOOLEAN gnc_InitMultiplication(ring r, bool bSetupQuotient = false); // just for a moment
 
 #endif // PLURAL_INTERNAL_DECLARATIONS

kernel/ideals.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ideals.cc,v 1.55 2008-04-04 09:51:37 Singular Exp $ */
+/* $Id: ideals.cc,v 1.56 2008-06-10 10:17:31 motsak Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate ideals
@@ -26 +26 @@
 
 
+#define MYTEST 0
+
+
 /* #define WITH_OLD_MINOR */
 #define pCopy_noCheck(p) pCopy(p)
@@ -65 +68 @@
 void idShow(ideal id)
 {
-  Print("Module of rank %d,real rank %d 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]);
+  if( id == NULL )
+    Print("(NULL)");
+  else
+  {
+    Print("Module of rank %d,real rank %d 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]);
+      }
     }
   }
@@ -1299 +1307 @@
   }
   h2->rank = syzcomp+i+1;
+
+#if MYTEST
+#ifdef RDEBUG
+  Print("Prepare::h2: ");
+  idPrint(h2);
+#endif  
+#endif
+  
   for (j=0; j<=i; j++)
   {
@@ -1316 +1332 @@
 #ifdef PDEBUG
   for(j=0;j<IDELEMS(h2);j++) pTest(h2->m[j]);
+
+#if MYTEST
+#ifdef RDEBUG
+  Print("Prepare::Input: ");
+  idPrint(h2);
+
+  Print("Prepare::currQuotient: ");
+  idPrint(currQuotient);
+#endif  
 #endif
-  h3=kStd(h2,currQuotient,h,w,NULL,syzcomp);
+  
+#endif
+
+  
+  h3 = kStd(h2,currQuotient,h,w,NULL,syzcomp);
   idDelete(&h2);
   return h3;
@@ -1528 +1557 @@
   if (k==1) verbose |=Sy_bit(V_IDLIFT);
 
-  ring orig_ring=currRing;
-  ring syz_ring=rCurrRingAssure_SyzComp();
+  ring orig_ring = currRing;
+  ring syz_ring = rCurrRingAssure_SyzComp();
   rSetSyzComp(k);
 
+  
+#if MYTEST
+#ifdef RDEBUG
+  rWrite(syz_ring);
+  rDebugPrint(syz_ring);
+#endif  
+#endif
+  
   ideal s_h1=h1;
 
@@ -1539 +1576 @@
     s_h1 = h1;
 
+#if MYTEST
+#ifdef RDEBUG
+  Print("Input: ");
+  idPrint(s_h1);
+#endif  
+#endif
+ 
+
   ideal s_h3=idPrepare(s_h1,h,k,&w);
+
+#if MYTEST
+#ifdef RDEBUG
+  Print("Prepare: ");
+  idPrint(s_h3);
+#endif  
+#endif
+
   ideal s_h2 = idInit(IDELEMS(s_h3), s_h3->rank);
 
+#if MYTEST
+#ifdef RDEBUG
+  Print("Temp: ");
+  idPrint(s_h2);
+#endif  
+#endif
+  
   if (w!=NULL) delete w;
   i = 0;
+
   for (j=0; j<IDELEMS(s_h3); j++)
   {
@@ -1571 +1632 @@
 
   idSkipZeroes(s_h3);
+
+#if MYTEST
+#ifdef RDEBUG
+  Print("Input'': ");
+  idPrint(s_h3);
+#endif  
+#endif
+
   j = IDELEMS(s_h1);
 
+
+#if MYTEST
+#ifdef RDEBUG
+  Print("Temp Result: ");
+  idPrint(s_h2);
+#endif  
+#endif
+
+  
   if (syz_ring!=orig_ring)
   {
@@ -1609 +1687 @@
     s_h3->m[i] = prMoveR_NoSort(s_h3->m[i], syz_ring);
   }
+
+#if MYTEST
+#ifdef RDEBUG
+  Print("Output STD Ideal: ");
+  idPrint(s_h3);
+
+  Print("Output Matrix: ");
+  iiWriteMatrix(*ma, "ma", 2, 4);
+#endif  
+#endif
+  
 
   if (syz_ring!=orig_ring) rKill(syz_ring);
@@ -2328 +2417 @@
   if (idIs0(h1)) return idInit(1,h1->rank);
 #ifdef HAVE_PLURAL
-  if (rIsPluralRing(currRing))
+  if (rIsPluralRing(origR))
     /* in the NC case, we have to check the admissibility of */
     /* the subalgebra to be intersected with */
   {
-    if (ncRingType(currRing)!=nc_skew) /* in (quasi)-commutative algebras every subalgebra is admissible */
-    {
-      if (nc_CheckSubalgebra(delVar,currRing))
+    if ((ncRingType(origR) != nc_skew) && (ncRingType(origR) != nc_exterior)) /* in (quasi)-commutative algebras every subalgebra is admissible */
+    {
+      if (nc_CheckSubalgebra(delVar,origR))
       {
         WerrorS("no elimination is possible: subalgebra is not admissible");
@@ -2362 +2451 @@
   block0[0] = 1;
   block1[0] = rVar(origR);
-  wv[0]=(int*)omAlloc((pVariables+1)*sizeof(int));
-  memset(wv[0],0,(pVariables+1)*sizeof(int));
+  wv[0]=(int*)omAlloc((rVar(origR) + 1)*sizeof(int));
+  memset(wv[0],0,(rVar(origR) + 1)*sizeof(int));
   for (j=0;j<rVar(origR);j++)
     if (pGetExp(delVar,j+1)!=0) wv[0][j]=1;
@@ -2376 +2465 @@
   tmpR->block1 = block1;
   tmpR->wvhdl = wv;
+
   rComplete(tmpR, 1);
 
 #ifdef HAVE_PLURAL
   /* update nc structure on tmpR */
-  if (rIsPluralRing(currRing))
-  {
-    BOOLEAN bBAD = FALSE;
-    if ( nc_rComplete(origR, tmpR) )
+  if (rIsPluralRing(origR))
+  {
+    if ( nc_rComplete(origR, tmpR, false) ) // no quotient ideal!
     {
       Werror("error in nc_rComplete");
-      bBAD = TRUE;
-    }
-    if (!bBAD)
-    {
-      /* tests the admissibility of the new elim. ordering */
-      if ( nc_CheckOrdCondition( tmpR->nc->D, tmpR) )
-      {
-        Werror("no elimination is possible: ordering condition is violated");
-        bBAD = TRUE;
-      }
-    }
-    if (bBAD)
-    {
       // cleanup
       rDelete(tmpR);
       if (w!=NULL)
-      {
         delete w;
-      }
       return idCopy(h1);
     }

kernel/kstd1.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd1.cc,v 1.34 2008-03-20 11:22:44 Singular Exp $ */
+/* $Id: kstd1.cc,v 1.35 2008-06-10 10:17:31 motsak Exp $ */
 /*
 * ABSTRACT:
@@ -1959 +1959 @@
   kStrategy strat=new skStrategy;
   strat->syzComp = syzComp;
+
+  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;
+
   if (pOrdSgn==-1)
-    p=kNF1(F,Q,p,strat,lazyReduce);
+    res=kNF1(F,Q,pp,strat,lazyReduce);
   else
-    p=kNF2(F,Q,p,strat,lazyReduce);
+    res=kNF2(F,Q,pp,strat,lazyReduce);
   delete(strat);
-  return p;
+
+#ifdef HAVE_PLURAL
+  if(pp != p)
+    p_Delete(&pp, currRing);
+#endif
+  
+  return res;
 }
 
@@ -1976 +1999 @@
   kStrategy strat=new skStrategy;
   strat->syzComp = syzComp;
+
+  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);
+
+    if(Q == currQuotient)
+      Q = SCAQuotient(currRing);
+  }
+#endif
+
   if (pOrdSgn==-1)
-    res=kNF1(F,Q,p,strat,lazyReduce);
+    res=kNF1(F,Q,pp,strat,lazyReduce);
   else
-    res=kNF2(F,Q,p,strat,lazyReduce);
+    res=kNF2(F,Q,pp,strat,lazyReduce);
   delete(strat);
+
+#ifdef HAVE_PLURAL
+  if(pp != p)
+    id_Delete(&pp, currRing);
+#endif
+
+  
   return res;
 }
@@ -2244 +2288 @@
 
     // this should be done on the upper level!!! :
-    //    tempQ = currRing->nc->SCAQuotient();
+    //    tempQ = SCAQuotient(currRing);
 
     if(Q == currQuotient)
-      tempQ = currRing->nc->SCAQuotient();
+      tempQ = SCAQuotient(currRing);
   }
 #endif

kernel/kutil.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kutil.cc,v 1.90 2008-05-20 15:30:00 Singular Exp $ */
+/* $Id: kutil.cc,v 1.91 2008-06-10 10:17:32 motsak Exp $ */
 /*
 * ABSTRACT: kernel: utils for kStd
@@ -1377 +1377 @@
   pSetm(Lp.lcm);
 
+#define MYTEST 0
+
 #ifdef HAVE_PLURAL
   const BOOLEAN bIsPluralRing = rIsPluralRing(currRing);
   const BOOLEAN bIsSCA        = rIsSCA(currRing) && strat->homog; // for prod-crit
   const BOOLEAN bNCProdCrit   = ( !bIsPluralRing || bIsSCA ); // commutative or homogeneous SCA
+
 #else
   const BOOLEAN bIsPluralRing = FALSE;
@@ -1386 +1389 @@
   const BOOLEAN bNCProdCrit   = TRUE;
 #endif
+
 
   if (strat->sugarCrit && bNCProdCrit)
@@ -1521 +1525 @@
   if (strat->fromT && !TEST_OPT_INTSTRATEGY)
     pNorm(p);
+
   if ((strat->S[i]==NULL) || (p==NULL))
     return;
+
   if ((strat->fromQ!=NULL) && (isFromQ!=0) && (strat->fromQ[i]!=0))
     Lp.p=NULL;
@@ -1532 +1538 @@
       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]);
-        }
-        else
+//         if(ncRingType(currRing) == nc_lie)
+//         {
+//             // generalized prod-crit for lie-type
+//             strat->cp++;
+//             Lp.p = nc_p_Bracket_qq(pCopy(p),strat->S[i]);
+//         }
+//         else
         if( bIsSCA )
         {
@@ -1546 +1552 @@
         }
         else
-          Lp.p = nc_CreateSpoly(strat->S[i],p,currRing); // ?
-      }
-      else  Lp.p = nc_CreateSpoly(strat->S[i],p,currRing);
+          Lp.p = nc_CreateSpoly(strat->S[i],p,currRing); 
+// nc_CreateShortSpoly(strat->S[i], p, strat->tailRing); // how to mark a short spoly?
+      }
+      else  Lp.p = nc_CreateSpoly(strat->S[i],p,currRing); 
+// nc_CreateShortSpoly(strat->S[i], p, strat->tailRing); // how to mark a short spoly?
+
+      
+#if MYTEST
+      if (TEST_OPT_DEBUG)
+      {
+        PrintS("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("strat->S[i]: "); pWrite(strat->S[i]);
+        PrintS("p: "); pWrite(p);
+        PrintS("commutative SPoly: "); pWrite(Lp.p);
+      }
+#endif      
+
+      }
   }
   if (Lp.p == NULL)
@@ -1655 +1684 @@
   if (rIsPluralRing(currRing))
   {
-    Lp.p = nc_CreateShortSpoly(strat->S[i],p); // ???
+    Lp.p = nc_CreateShortSpoly(strat->S[i],p); // ??? strat->tailRing?
   }
   else
@@ -2784 +2813 @@
   assume (!rField_is_Ring(currRing));
 #endif
+
   initenterpairs(h,k,ecart,0,strat, atR);
   if ( (!strat->fromT)
@@ -4073 +4103 @@
     else
     {
-      assume (j >= 0 && j <= strat->tl && strat->S_2_T(j) != NULL &&
-              strat->S_2_T(j)->p == strat->S[j]);
+/////      assume (j >= 0 && j <= strat->tl && strat->S_2_T(j) != NULL
+/////      && strat->S_2_T(j)->p == strat->S[j]); // wrong?
+//      assume (j >= 0 && j <= strat->sl && strat->S_2_T(j) != NULL && strat->S_2_T(j)->p == strat->S[j]);
       return strat->S_2_T(j);
     }

kernel/longalg.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: longalg.cc,v 1.32 2008-03-19 17:44:09 Singular Exp $ */
+/* $Id: longalg.cc,v 1.33 2008-06-10 10:17:32 motsak Exp $ */
 /*
 * ABSTRACT:   algebraic numbers
@@ -1673 +1673 @@
   }
   else
-#if 0
+#ifndef HAVE_FACTORY
     result->z = napGcd(x->z, y->z); // change from napGcd0
 #else

kernel/maps.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: maps.cc,v 1.8 2008-04-21 14:18:16 Singular Exp $ */
+/* $Id: maps.cc,v 1.9 2008-06-10 10:17:32 motsak Exp $ */
 /*
 * ABSTRACT - the mapping of polynomials to other rings
@@ -21 +21 @@
 #include "prCopy.h"
 
+#ifdef HAVE_PLURAL
+#include "gring.h"
+#endif
+
 // This is a very dirty way to "normalize" numbers w.r.t. a
 // MinPoly
@@ -197 +201 @@
 ideal maGetPreimage(ring theImageRing, map theMap, ideal id)
 {
+  ring sourcering = currRing;
+
+#ifdef HAVE_PLURAL
+  if (rIsPluralRing(theImageRing))
+  {
+    if ((rIsPluralRing(sourcering)) && (ncRingType(sourcering)!=nc_comm)) 
+    {
+      Werror("Sorry, not yet implemented for noncomm. rings");
+      return NULL;
+    }
+  }
+#endif
+  
   int i,j;
   poly p,pp,q;
@@ -203 +220 @@
 
   int imagepvariables = theImageRing->N;
-  ring sourcering = currRing;
   int N = pVariables+imagepvariables;
 
@@ -213 +229 @@
   }
 
-#ifdef HAVE_PLURAL
-  if (rIsPluralRing(theImageRing))
-  {
-    if ((rIsPluralRing(sourcering)) && (ncRingType(sourcering)!=nc_comm)) 
-    {
-      Werror("Sorry, not yet implemented for noncomm. rings");
-      return NULL;
-    }    
-  }
   if (nSetMap(theImageRing) != nCopy)
   {
@@ -227 +234 @@
     return NULL;
   }
-#endif
 
   // change to new ring

kernel/matpol.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: matpol.cc,v 1.13 2006-11-20 11:10:39 Singular Exp $ */
+/* $Id: matpol.cc,v 1.14 2008-06-10 10:17:32 motsak Exp $ */
 
 /*
@@ -24 +24 @@
 #include "sparsmat.h"
 #include "matpol.h"
-
+#include "prCopy.h"
 
 //omBin ip_smatrix_bin = omGetSpecBin(sizeof(ip_smatrix));
@@ -101 +101 @@
   return b;
 }
+
+/*2
+*copies matrix a from rSrc into rDst
+*/
+matrix mpCopy(const matrix a, const ring rSrc, const ring rDst)
+{
+  const ring save = currRing;
+
+  if( save != currRing )
+    rChangeCurrRing(rSrc);
+
+  idTest((ideal)a);
+
+  rChangeCurrRing(rDst);
+
+  poly t;
+  int i, m=MATROWS(a), n=MATCOLS(a);
+
+  matrix b = mpNew(m, n);
+
+  for (i=m*n-1; i>=0; i--)
+  {
+    t = a->m[i];
+    if (t!=NULL)
+    {
+      b->m[i] = prCopyR_NoSort(t, rSrc, rDst);
+      p_Normalize(b->m[i], rDst);
+    }
+  }
+  b->rank=a->rank;
+
+  idTest((ideal)b);
+
+  if( save != currRing )
+    rChangeCurrRing(save);
+
+  return b;
+}
+
+
 
 /*2
@@ -416 +456 @@
 /*--- look for an optimal row and bring it to last position ------------*/
     if(mpPrepareRow(a,lr,lc)==0) break;
-/*--- now take all pivotŽs from the last row ------------*/
+/*--- now take all pivots from the last row ------------*/
     k = lc;
     loop
@@ -1877 +1917 @@
 }
 
+void   mpDelete(matrix* a, const ring r)
+{
+  id_Delete((ideal *) a, r);
+}

kernel/matpol.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: matpol.h,v 1.1.1.1 2003-10-06 12:15:57 Singular Exp $ */
+/* $Id: matpol.h,v 1.2 2008-06-10 10:17:32 motsak Exp $ */
 /*
 * ABSTRACT
@@ -30 +30 @@
 
 matrix mpNew(int r, int c);
-matrix mpCopy (matrix a);
+matrix mpCopy(matrix a);
+void   mpDelete(matrix* a, const ring r = currRing);
+matrix mpCopy(const matrix a, const ring rSrc, const ring rDst = currRing);
 matrix mpInitP(int r, int c, poly p);
 matrix mpInitI(int r, int c, int v);

kernel/pInline2.h

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: pInline2.h,v 1.12 2007-03-10 15:41:49 levandov Exp $
+ *  Version: $Id: pInline2.h,v 1.13 2008-06-10 10:17:32 motsak Exp $
  *******************************************************************/
 #ifndef PINLINE2_H
@@ -128 +128 @@
   return __p_GetComp(p,r) -= v;
 }
+PINLINE2 int p_Comp_k_n(poly a, poly b, int k, ring r)
+{
+  if ((a==NULL) || (b==NULL) ) return FALSE;
+  p_LmCheckPolyRing2(a, r);
+  p_LmCheckPolyRing2(b, r);
+  pAssume2(k > 0 && k <= r->N);
+  int i=k;
+  for(;i<=r->N;i++)
+  {
+    if (p_GetExp(a,i,r) != p_GetExp(b,i,r)) return FALSE;
+    //    if (a->exp[(r->VarOffset[i] & 0xffffff)] != b->exp[(r->VarOffset[i] & 0xffffff)]) return FALSE;
+  }
+  return TRUE;
+}
+
+
+#ifndef HAVE_EXPSIZES
 
 // exponent
@@ -147 +164 @@
 #endif
 }
+
 // partial compare exponent
 // r->VarOffset encodes the position in p->exp (lower 24 bits)
 // and number of bits to shift to the right in the upper 8 bits
-PINLINE2 int p_Comp_k_n(poly a, poly b, int k, ring r)
-{
-  if ((a==NULL) || (b==NULL) ) return FALSE;
-  p_LmCheckPolyRing2(a, r);
-  p_LmCheckPolyRing2(b, r);
-  pAssume2(k > 0 && k <= r->N);
-  int i=k;
-  for(;i<=r->N;i++)
-  {
-    if (p_GetExp(a,i,r) != p_GetExp(b,i,r)) return FALSE;
-    //    if (a->exp[(r->VarOffset[i] & 0xffffff)] != b->exp[(r->VarOffset[i] & 0xffffff)]) return FALSE;
-  }
-  return TRUE;
-}
 PINLINE2 int p_SetExp(poly p, int v, int e, ring r)
 {
@@ -182 +186 @@
   return e;
 }
+
+#else // #ifdef HAVE_EXPSIZES
+
+inline int BitMask(int bitmask, int twobits)
+{
+  // bitmask = 00000111111111111
+  // 0 must give bitmask!
+  // 1, 2, 3 - anything like 00011..11
+  pAssume2((twobits >> 2) == 0);
+  const int _bitmasks[4] = {0xffffffff, 0x7fff, 0x7f, 0x3}; 
+  return bitmask & _bitmasks[twobits]; 
+}
+
+PINLINE2 int p_GetExp(poly p, int v, ring r)
+{
+  p_LmCheckPolyRing2(p, r);
+  pAssume2(v > 0 && v <= r->N);
+#if 1 // new!!
+  int pos  =(r->VarOffset[v] & 0xffffff);
+  int hbyte= (r->VarOffset[v] >> 24); // the highest byte
+  int bitpos = hbyte & 0x3f; // last 6 bits
+  int bitmask = BitMask(r->bitmask, hbyte >> 6); 
+
+  int exp=(p->exp[pos] >> bitpos) & bitmask;
+  return exp;
+#else
+  // old
+  return (int)
+      ((p->exp[(r->VarOffset[v] & 0xffffff)] >> (r->VarOffset[v] >> 24))
+       & r->bitmask;
+#endif
+}
+
+
+// partial compare exponent
+// r->VarOffset encodes the position in p->exp (lower 24 bits)
+// and number of bits to shift to the right in the upper 8 bits
+PINLINE2 int p_SetExp(poly p, int v, int e, ring r)
+{
+  p_LmCheckPolyRing2(p, r);
+  pAssume2(v>0 && v <= r->N);
+  pAssume2(e>=0);
+  pAssume2((unsigned int) e <= BitMask(r->bitmask, r->VarOffset[v] >> 30));
+
+  // shift e to the left:
+  register int hbyte = r->VarOffset[v] >> 24;
+  int bitmask = BitMask(r->bitmask, hbyte >> 6);
+  register int shift = hbyte & 0x3f;
+  unsigned long ee = ((unsigned long)e) << shift;
+  // find the bits in the exponent vector
+  register int offset = (r->VarOffset[v] & 0xffffff);
+  // clear the bits in the exponent vector:
+  p->exp[offset]  &= ~( bitmask << shift );
+  // insert e with |
+  p->exp[ offset ] |= ee;
+  return e;
+}
+
+#endif // #ifndef HAVE_EXPSIZES
 
 // the following should be implemented more efficiently

kernel/p_Procs_Set.h

@@ -12 +12 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 12/00
- *  Version: $Id: p_Procs_Set.h,v 1.14 2008-03-19 17:44:10 Singular Exp $
+ *  Version: $Id: p_Procs_Set.h,v 1.15 2008-06-10 10:17:32 motsak Exp $
  *******************************************************************/
 #include "modulop.h"
@@ -185 +185 @@
 #ifdef HAVE_PLURAL
   if (rIsPluralRing(r))
-    nc_p_ProcsSet(r, _p_procs); // Setup non-commutative p_Procs table!
+  {
+     WarnS("Setting pProcs in p_ProcsSet (rDebugPrint!?)!!!");
+     nc_p_ProcsSet(r, _p_procs); // Setup non-commutative p_Procs table!
+  }
 #endif
 }
@@ -204 +207 @@
 {
   set_names = 1;
-  p_ProcsSet(r, p_Procs);
+  p_ProcsSet(r, p_Procs); // changes p_Procs!!!
   set_names = 0;
 }

kernel/ratgring.cc

@@ -7 +7 @@
  *  Author:  levandov (Viktor Levandovsky)
  *  Created: 8/00 - 11/00
- *  Version: $Id: ratgring.cc,v 1.9 2008-01-31 13:23:25 Singular Exp $
+ *  Version: $Id: ratgring.cc,v 1.10 2008-06-10 10:17:32 motsak Exp $
  *******************************************************************/
 #include "mod2.h"
@@ -379 +379 @@
   poly H  = NULL;
   HH = p_Copy(p_HeadRat(p1,is,r),r); // lm_D(g)
-  H  = r->nc->p_Procs.mm_Mult_p(m, p_Copy(HH, r), r); // d^aplha lm_D(g)
+//  H  = r->nc->p_Procs.mm_Mult_p(m, p_Copy(HH, r), r); // d^aplha lm_D(g)
+  H  = nc_mm_Mult_pp(m, HH, r); // d^aplha lm_D(g)
 
   poly K  = p_Copy( p_GetCoeffRat(H,  is, r), r);
@@ -427 +428 @@
   Print("k' t_f: "); p_wrp(p2,r);
 
-  out = r->nc->p_Procs.mm_Mult_p(m, out, r); // d^aplha t_g
+//  out = r->nc->p_Procs.mm_Mult_p(m, out, r); // d^aplha t_g
+  out = nc_mm_Mult_p(m, out, r); // d^aplha t_g  
+  
   p_Delete(&m,r);
 

kernel/ring.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ring.cc,v 1.81 2008-04-22 16:14:14 Singular Exp $ */
+/* $Id: ring.cc,v 1.82 2008-06-10 10:17:32 motsak Exp $ */
 
 /*
@@ -390 +390 @@
   }
 #ifdef HAVE_PLURAL
-  if (r->nc!=NULL)
+  if(rIsPluralRing(r))
   {
     PrintS("\n//   noncommutative relations:");
@@ -398 +398 @@
       int nl;
       int i,j;
-      //    Print("\n//   noncommutative relations (type %d):",(int)r->nc->type);
       for (i = 1; i<r->N; i++)
       {
         for (j = i+1; j<=r->N; j++)
         {
-          nl = nIsOne(p_GetCoeff(MATELEM(r->nc->C,i,j),r));
-          if ( (MATELEM(r->nc->D,i,j)!=NULL) || (!nl) )
+          nl = nIsOne(p_GetCoeff(MATELEM(r->GetNC()->C,i,j),r));
+          if ( (MATELEM(r->GetNC()->D,i,j)!=NULL) || (!nl) )
           {
             Print("\n//    %s%s=",r->names[j-1],r->names[i-1]);
-            pl = MATELEM(r->nc->MT[UPMATELEM(i,j,r->N)],1,1);
+            pl = MATELEM(r->GetNC()->MT[UPMATELEM(i,j,r->N)],1,1);
             pWrite0(pl);
           }
@@ -416 +415 @@
 #ifdef PDEBUG
     Print("\n//   noncommutative type:%d", (int)ncRingType(r));
-    Print("\n//   is skew constant:%d",r->nc->IsSkewConstant);
+    Print("\n//   is skew constant:%d",r->GetNC()->IsSkewConstant);
     if( rIsSCA(r) )
     {
       Print("\n//   alternating variables: [%d, %d]", scaFirstAltVar(r), scaLastAltVar(r));
-      const ideal Q = r->nc->SCAQuotient(); // resides within r!
+      const ideal Q = SCAQuotient(r); // resides within r!
       if (Q!=NULL)
       {
@@ -432 +431 @@
       }
     }
-    Print("\n//   ref:%d",r->nc->ref);
+    Print("\n//   ref:%d",r->GetNC()->ref);
 #endif
   }
@@ -455 +454 @@
 
 #ifdef HAVE_PLURAL
-  if (r->nc != NULL)
-  {
-    if (r->nc->ref>1) /* in use by somebody else */
-    {
-      r->nc->ref--;
-    }
-    else
-    {
-      ncKill(r);
-    }
-  }
-#endif
+  if (rIsPluralRing(r))
+    ncKill(r);
+#endif
+
   nKillChar(r);
   rUnComplete(r);
@@ -1065 +1056 @@
   tmpR.OrdSgn=1;
   if (dp_dp
-  && !rIsPluralRing(r1) && !rIsPluralRing(r2))
+#ifdef HAVE_PLURAL
+      && !rIsPluralRing(r1) && !rIsPluralRing(r2)
+#endif      
+     )
   {
     tmpR.order=(int*)omAlloc(4*sizeof(int));
@@ -1225 +1219 @@
   memcpy(sum,&tmpR,sizeof(ip_sring));
   rComplete(sum);
+
 //#ifdef RDEBUG
 //  rDebugPrint(sum);
 //#endif
+
 #ifdef HAVE_PLURAL
-  ring old_ring = currRing;
-  BOOLEAN R1_is_nc = rIsPluralRing(r1);
-  BOOLEAN R2_is_nc = rIsPluralRing(r2);
-  if ( (R1_is_nc) || (R2_is_nc))
-  {
-    rChangeCurrRing(r1); /* since rCopy works well only in currRing */
-    ring R1 = rCopy(r1);
-    rChangeCurrRing(r2);
-    ring R2 = rCopy(r2);
-    rChangeCurrRing(sum);
-    /* basic nc constructions  */
-    sum->nc = (nc_struct *)omAlloc0(sizeof(nc_struct));
-    sum->nc->ref = 1;
-    sum->nc->basering = sum;
-    if ( !R1_is_nc ) nc_rCreateNCcomm(R1);
-    if ( !R2_is_nc ) nc_rCreateNCcomm(R2);
-    /* nc->type's */
-    ncRingType(sum, nc_undef);
-    nc_type t1 = ncRingType(R1), t2 = ncRingType(R2);
-    if ( t1==t2) ncRingType(sum, t1);
-    else
-    {
-      if ( (t1==nc_general) || (t2==nc_general) ) ncRingType(sum, nc_general);
-    }
-    if (ncRingType(sum) == nc_undef) /* not yet done */
-    {
-      switch (t1)
-      {
-        case nc_comm:
-          ncRingType(sum, t2);
-          break;
-        case nc_lie:
-          switch(t2)
-          {
-            case nc_skew:
-              ncRingType(sum, nc_general);  break;
-            case nc_comm:
-              ncRingType(sum, nc_lie);  break;
-            default:
-              /*sum->nc->type = nc_undef;*/  break;
-          }
-          break;
-        case nc_skew:
-          switch(t2)
-          {
-            case nc_lie:
-              ncRingType(sum, nc_lie);  break;
-            case nc_comm:
-              ncRingType(sum, nc_skew);  break;
-            default:
-              /*sum->nc->type = nc_undef;*/  break;
-          }
-        default:
-          /*sum->nc->type = nc_undef;*/
-          break;
-      }
-    }
-    if (ncRingType(sum) == nc_undef)
-      WarnS("Error on recognizing nc types");
-    /* multiplication matrices business: */
-    /* find permutations of vars and pars */
-    int *perm1 = (int *)omAlloc0((rVar(R1)+1)*sizeof(int));
-    int *par_perm1 = NULL;
-    if (rPar(R1)!=0) par_perm1=(int *)omAlloc0((rPar(R1)+1)*sizeof(int));
-    int *perm2 = (int *)omAlloc0((rVar(R2)+1)*sizeof(int));
-    int *par_perm2 = NULL;
-    if (rPar(R2)!=0) par_perm2=(int *)omAlloc0((rPar(R2)+1)*sizeof(int));
-    maFindPerm(R1->names,  rVar(R1),  R1->parameter,  rPar(R1),
-               sum->names, rVar(sum), sum->parameter, rPar(sum),
-               perm1, par_perm1, sum->ch);
-    maFindPerm(R2->names,  rVar(R2),  R2->parameter,  rPar(R2),
-               sum->names, rVar(sum), sum->parameter, rPar(sum),
-               perm2, par_perm2, sum->ch);
-    nMapFunc nMap1 = nSetMap(R1);
-    nMapFunc nMap2 = nSetMap(R2);
-    matrix C1 = R1->nc->C, C2 = R2->nc->C;
-    matrix D1 = R1->nc->D, D2 = R2->nc->D;
-
-    // !!!! BUG? C1 and C2 might live in different baserings!!!
-    // it cannot be both the currRing! :)
-    // the currRing is sum!
-
-    int l = rVar(R1) + rVar(R2);
-    matrix C  = mpNew(l,l);
-    matrix D  = mpNew(l,l);
-    int param_shift = 0;
-    for (i=1; i<= rVar(R1) + rVar(R2); i++)
-    {
-      for (j= i+1; j<= rVar(R1) + rVar(R2); j++)
-      {
-        MATELEM(C,i,j) = pOne();
-      }
-    }
-    sum->nc->C = C;
-    sum->nc->D = D;
-    if (nc_InitMultiplication(sum))
-      WarnS("Error initializing multiplication!");
-    for (i=1; i< rVar(R1); i++)
-    {
-      for (j=i+1; j<=rVar(R1); j++)
-      {
-
-        MATELEM(C,i,j) = pPermPoly(MATELEM(C1,i,j),perm1,R1,nMap1,par_perm1,rPar(R1));
-        if (MATELEM(D1,i,j) != NULL)
-        {
-          MATELEM(D,i,j) = pPermPoly(MATELEM(D1,i,j),perm1,R1,nMap1,par_perm1,rPar(R1));
-        }
-      }
-    }
-    idTest((ideal)C);
-    for (i=1; i< rVar(R2); i++)
-    {
-      for (j=i+1; j<=rVar(R2); j++)
-      {
-        MATELEM(C,rVar(R1)+i,rVar(R1)+j) = pPermPoly(MATELEM(C2,i,j),perm2,R2,nMap2,par_perm2,rPar(R2));
-        if (MATELEM(D2,i,j) != NULL)
-        {
-          MATELEM(D,rVar(R1)+i,rVar(R1)+j) = pPermPoly(MATELEM(D2,i,j),perm2,R2,nMap2,par_perm2,rPar(R2));
-        }
-      }
-    }
-    idTest((ideal)D);
-    if (nc_InitMultiplication(sum))
-      WarnS("Error initializing multiplication!");
-    sum->nc->IsSkewConstant =(int)((R1->nc->IsSkewConstant) && (R2->nc->IsSkewConstant));
-    /* delete R1, R2*/
-    rDelete(R1);
-    rDelete(R2);
-    /* delete perm arrays */
-    if (perm1!=NULL) omFree((ADDRESS)perm1);
-    if (perm2!=NULL) omFree((ADDRESS)perm2);
-    if (par_perm1!=NULL) omFree((ADDRESS)par_perm1);
-    if (par_perm2!=NULL) omFree((ADDRESS)par_perm2);
-    rChangeCurrRing(old_ring);
-  }
-#endif
+  if(1)
+  {
+    ring old_ring = currRing;
+
+    BOOLEAN R1_is_nc = rIsPluralRing(r1);
+    BOOLEAN R2_is_nc = rIsPluralRing(r2);
+
+    if ( (R1_is_nc) || (R2_is_nc))
+    {
+      rChangeCurrRing(r1); /* since rCopy works well only in currRing */
+      ring R1 = rCopy(r1);
+      if ( !R1_is_nc ) nc_rCreateNCcomm(R1);
+
+#if 0
+#ifdef RDEBUG
+      rWrite(R1);
+      rDebugPrint(R1);
+#endif
+#endif
+      rChangeCurrRing(r2);
+      ring R2 = rCopy(r2);
+      if ( !R2_is_nc ) nc_rCreateNCcomm(R2);
+
+#if 0
+#ifdef RDEBUG
+      rWrite(R2);
+      rDebugPrint(R2);
+#endif
+#endif
+
+      rChangeCurrRing(sum); // ?
+
+      // Projections from R_i into Sum:
+      /* multiplication matrices business: */
+      /* find permutations of vars and pars */
+      int *perm1 = (int *)omAlloc0((rVar(R1)+1)*sizeof(int));
+      int *par_perm1 = NULL;
+      if (rPar(R1)!=0) par_perm1=(int *)omAlloc0((rPar(R1)+1)*sizeof(int));
+
+      int *perm2 = (int *)omAlloc0((rVar(R2)+1)*sizeof(int));
+      int *par_perm2 = NULL;
+      if (rPar(R2)!=0) par_perm2=(int *)omAlloc0((rPar(R2)+1)*sizeof(int));
+
+      maFindPerm(R1->names,  rVar(R1),  R1->parameter,  rPar(R1),
+                 sum->names, rVar(sum), sum->parameter, rPar(sum),
+                 perm1, par_perm1, sum->ch);
+
+      maFindPerm(R2->names,  rVar(R2),  R2->parameter,  rPar(R2),
+                 sum->names, rVar(sum), sum->parameter, rPar(sum),
+                 perm2, par_perm2, sum->ch);
+
+      nMapFunc nMap1 = nSetMap(R1);
+      nMapFunc nMap2 = nSetMap(R2);
+
+      matrix C1 = R1->GetNC()->C, C2 = R2->GetNC()->C;
+      matrix D1 = R1->GetNC()->D, D2 = R2->GetNC()->D;
+
+      // !!!! BUG? C1 and C2 might live in different baserings!!!
+      // it cannot be both the currRing! :)
+      // the currRing is sum!
+
+      int l = rVar(R1) + rVar(R2);
+
+      matrix C  = mpNew(l,l);
+      matrix D  = mpNew(l,l);
+
+      int param_shift = 0;
+
+      for (i = 1; i <= rVar(R1); i++)
+        for (j= rVar(R1)+1; j <= l; j++)
+          MATELEM(C,i,j) = p_ISet(1, sum); // in 'sum'
+
+      idTest((ideal)C);
+
+      // Create blocked C and D matrices:
+      for (i=1; i<= rVar(R1); i++)
+        for (j=i+1; j<=rVar(R1); j++)
+        {
+          assume(MATELEM(C1,i,j) != NULL);
+          MATELEM(C,i,j) = pPermPoly(MATELEM(C1,i,j), perm1, R1, nMap1, par_perm1, rPar(R1)); // need ADD + CMP ops.
+
+          if (MATELEM(D1,i,j) != NULL)
+            MATELEM(D,i,j) = pPermPoly(MATELEM(D1,i,j),perm1,R1,nMap1,par_perm1,rPar(R1));
+        }
+
+      idTest((ideal)C);
+      idTest((ideal)D);
+
+ 
+      for (i=1; i<= rVar(R2); i++)
+        for (j=i+1; j<=rVar(R2); j++)
+        {
+          assume(MATELEM(C2,i,j) != NULL);
+          MATELEM(C,rVar(R1)+i,rVar(R1)+j) = pPermPoly(MATELEM(C2,i,j),perm2,R2,nMap2,par_perm2,rPar(R2));
+
+          if (MATELEM(D2,i,j) != NULL)
+            MATELEM(D,rVar(R1)+i,rVar(R1)+j) = pPermPoly(MATELEM(D2,i,j),perm2,R2,nMap2,par_perm2,rPar(R2));
+        }
+
+      idTest((ideal)C);
+      idTest((ideal)D);
+
+      // Now sum is non-commutative with blocked structure constants!
+      if (nc_CallPlural(C, D, NULL, NULL, sum, false, false, true, sum))
+        WarnS("Error initializing non-commutative multiplication!");
+
+      /* delete R1, R2*/
+
+#if 0
+#ifdef RDEBUG
+      rWrite(sum);
+      rDebugPrint(sum);
+
+      Print("\nRefs: R1: %d, R2: %d\n", R1->GetNC()->ref, R2->GetNC()->ref);
+      
+#endif
+#endif
+
+          
+      rDelete(R1);
+      rDelete(R2);
+
+      /* delete perm arrays */
+      if (perm1!=NULL) omFree((ADDRESS)perm1);
+      if (perm2!=NULL) omFree((ADDRESS)perm2);
+      if (par_perm1!=NULL) omFree((ADDRESS)par_perm1);
+      if (par_perm2!=NULL) omFree((ADDRESS)par_perm2);
+
+      rChangeCurrRing(old_ring);
+    }
+  
+  }
+#endif
+
   ideal Q=NULL;
   ideal Q1=NULL, Q2=NULL;
@@ -1414 +1408 @@
   }
   sum->qideal = Q;
+
+#ifdef HAVE_PLURAL
+  if( rIsPluralRing(sum) )
+    nc_SetupQuotient( sum );
+#endif
   return 1;
 }
@@ -1506 +1505 @@
   }
 #ifdef HAVE_PLURAL
-  if (rIsPluralRing(r))
-  {
-    res->nc=r->nc;
-    res->nc->ref++;
-  }
+  res->GetNC() = NULL; // copy is purely commutative!!!
+//  if (rIsPluralRing(r))
+//    nc_rCopy0(res, r); // is this correct??? imho: no!
 #endif
   return res;
@@ -1525 +1522 @@
   if (r == NULL) return NULL;
   ring res=rCopy0(r);
-  rComplete(res, 1);
+  rComplete(res, 1); // res is purely commutative so far
+
+#ifdef HAVE_PLURAL
+  // update nc structure on res: share NC structure of r with res since they are the same!!!
+  // i.e. no data copy!!! Multiplications will be setuped as well!
+  if (rIsPluralRing(r))
+    nc_rCopy0(res, r);
+#endif
+
   return res;
 }
@@ -2436 +2441 @@
   ring res=(ring)omAlloc0Bin(ip_sring_bin);
   *res = *r;
+
+#ifdef HAVE_PLURAL
+  res->GetNC() = NULL;
+#endif
+  
   // res->qideal, res->idroot ???
   res->wvhdl=wvhdl;
@@ -2477 +2487 @@
   // it comes from dp
   res->OrdSgn=r->OrdSgn;
+
+
+#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..
+    }
+  }
+#endif
+  
   return res;
 }
@@ -2485 +2513 @@
   ring res=(ring)omAlloc0Bin(ip_sring_bin);
   *res = *r;
+#ifdef HAVE_PLURAL
+  res->GetNC() = NULL;
+#endif
+  
   /*weights: entries for 3 blocks: NULL*/
   res->wvhdl = (int **)omAlloc0(3 * sizeof(int_ptr));
@@ -2506 +2538 @@
   rComplete(res, 1);
   r->cf->ref=tmpref;
+#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..
+    }
+  }
+#endif
   return res;
 }
@@ -2538 +2585 @@
     ring res=(ring)omAlloc0Bin(ip_sring_bin);
     *res = *r;
+#ifdef HAVE_PLURAL
+    res->GetNC() = NULL;
+#endif    
     // res->qideal, res->idroot ???
     res->wvhdl=wvhdl;
@@ -2547 +2597 @@
     rComplete(res, 1);
     r->cf->ref=tmpref;
+
+#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..
+      }
+    }
+#endif
 
     rOptimizeLDeg(res);
@@ -3279 +3345 @@
   r->p_Procs = (p_Procs_s*)omAlloc(sizeof(p_Procs_s));
   p_ProcsSet(r, r->p_Procs);
-
   return FALSE;
 }
@@ -3506 +3571 @@
   const char* length;
   const char* ord;
-  p_Debug_GetProcNames(r, &proc_names);
+  p_Debug_GetProcNames(r, &proc_names); // changes p_Procs!!!
   p_Debug_GetSpecNames(r, field, length, ord);
 
@@ -3597 +3662 @@
 static ring rAssure_SyzComp(ring r, BOOLEAN complete = TRUE);
 
+#define MYTEST 0
+
 ring rCurrRingAssure_SyzComp()
 {
+#ifdef HAVE_PLURAL
+#if MYTEST
+  PrintS("rCurrRingAssure_SyzComp(), currRing:  \n");
+  rWrite(currRing);
+#ifdef RDEBUG
+  rDebugPrint(currRing);
+#endif
+#endif
+#endif
+
   ring r = rAssure_SyzComp(currRing);
+
   if (r != currRing)
   {
     ring old_ring = 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)
     {
@@ -3609 +3700 @@
       assume(idRankFreeModule(r->qideal) == 0);
       currQuotient = r->qideal;
-    }
-  }
+
+#ifdef HAVE_PLURAL
+      if( rIsPluralRing(r) )
+        nc_SetupQuotient(r);
+#endif      
+    }
+  }
+
+  assume(currRing == r);
+#ifdef HAVE_PLURAL
+#if MYTEST
+  PrintS("\nrCurrRingAssure_SyzComp(): new currRing: \n");
+  rWrite(currRing);
+#ifdef RDEBUG
+  rDebugPrint(currRing);
+#endif
+#endif
+#endif
+      
   return r;
 }
@@ -3641 +3749 @@
   res->wvhdl = wvhdl;
 
-  if (complete) rComplete(res, 1);
+  if (complete)
+  {
+    rComplete(res, 1);
+
+#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..
+      }
+    }
+#endif
+    
+  }
   return res;
 }
@@ -3683 +3811 @@
 
   rComplete(new_r, 1);
+
+#ifdef HAVE_PLURAL
+  if (rIsPluralRing(r))
+  {
+    if ( nc_rComplete(r, new_r, false) ) // no qideal!
+    {
+      WarnS("error in nc_rComplete");
+      // cleanup?
+
+//      rDelete(res);
+//      return r;
+
+      // just go on..
+    }
+  }
+#endif
+  
   return new_r;
 }
@@ -3717 +3862 @@
       new_r->block1[last_block] = r->block1[c_pos];
       new_r->wvhdl[last_block] = r->wvhdl[c_pos];
-      if (complete) rComplete(new_r, 1);
+      if (complete)
+      {
+        rComplete(new_r, 1);
+
+#ifdef HAVE_PLURAL
+        if (rIsPluralRing(r))
+        {
+          if ( nc_rComplete(r, new_r, false) ) // no qideal!
+          {
+            WarnS("error in nc_rComplete");
+      // cleanup?
+
+//      rDelete(res);
+//      return r;
+
+      // just go on..
+          }
+        }
+#endif
+        
+      }
       return new_r;
     }
@@ -3750 +3915 @@
     if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
     rComplete(new_r, 1);
+#ifdef HAVE_PLURAL
+    if (rIsPluralRing(old_r))
+    {
+      if ( nc_rComplete(old_r, new_r, false) ) // no qideal!
+      {
+        WarnS("error in nc_rComplete");
+      // cleanup?
+
+//      rDelete(res);
+//      return r;
+
+      // just go on..
+      }
+    }
+#endif
+   
     rChangeCurrRing(new_r);
     if (old_r->qideal != NULL)
@@ -3755 +3936 @@
       new_r->qideal = idrCopyR(old_r->qideal, old_r);
       currQuotient = new_r->qideal;
+
+#ifdef HAVE_PLURAL
+      if( rIsPluralRing(old_r) )
+        nc_SetupQuotient( new_r );
+#endif
+      
     }
     rTest(new_r);
@@ -3984 +4171 @@
   ring save = currRing;
   rChangeCurrRing(src);
+  
   ring r = rCopy0(src,TRUE); /* TRUE for copy the qideal */
   /*  rChangeCurrRing(r); */
@@ -4193 +4381 @@
   }
   rComplete(r);
+
+  
 #ifdef RDEBUG
   //   rDebugPrint(r);
-#endif
   rTest(r);
+#endif
+
+  rChangeCurrRing(r); 
+
 #ifdef HAVE_PLURAL
-  /* now, we initialize a non-comm structure on r */
-  if (!rIsPluralRing(src))
-  {
-    return r;
-  }
-  rChangeCurrRing(r);  /* we were not in r */
-  /* basic nc constructions  */
-  r->nc           = (nc_struct *)omAlloc0(sizeof(nc_struct));
-  r->nc->ref      = 1; /* in spite of rCopy(src)? */
-  r->nc->basering = r;
-  ncRingType(r, ncRingType(src));
-  int *perm       = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
-  int *par_perm   = NULL;
-  nMapFunc nMap   = nSetMap(src);
-  int ni,nj;
-  for(i=1; i<=r->N; i++)
-  {
-    perm[i] = rOppVar(r,i);
-  }
-  matrix C = mpNew(rVar(r),rVar(r));
-  matrix D = mpNew(rVar(r),rVar(r));
-  r->nc->C = C;
-  r->nc->D = D;
-  if (nc_InitMultiplication(r))
-    WarnS("Error initializing multiplication!");
-  for (i=1; i< rVar(r); i++)
-  {
-    for (j=i+1; j<=rVar(r); j++)
-    {
-      ni = r->N +1 - i;
-      nj = r->N +1 - j; /* i<j ==>   nj < ni */
-      MATELEM(C,nj,ni) = pPermPoly(MATELEM(src->nc->C,i,j),perm,src,nMap,par_perm,src->P);
-      MATELEM(D,nj,ni) = pPermPoly(MATELEM(src->nc->D,i,j),perm,src,nMap,par_perm,src->P);
-    }
-  }
-  idTest((ideal)C);
-  idTest((ideal)D);
-  if (nc_InitMultiplication(r))
-    WarnS("Error initializing multiplication!");
-  r->nc->IsSkewConstant =   src->nc->IsSkewConstant;
-  omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
+  // now, we initialize a non-comm structure on r
+  if (rIsPluralRing(src))
+  {
+    assume( currRing == r);
+    
+    int *perm       = (int *)omAlloc0((rVar(r)+1)*sizeof(int));
+    int *par_perm   = NULL;
+    nMapFunc nMap   = nSetMap(src);
+    int ni,nj;
+    for(i=1; i<=r->N; i++)
+    {
+      perm[i] = rOppVar(r,i);
+    }
+
+    matrix C = mpNew(rVar(r),rVar(r));
+    matrix D = mpNew(rVar(r),rVar(r));
+
+    for (i=1; i< rVar(r); i++)
+    {
+      for (j=i+1; j<=rVar(r); j++)
+      {
+        ni = r->N +1 - i;
+        nj = r->N +1 - j; /* i<j ==>   nj < ni */
+
+        assume(MATELEM(src->GetNC()->C,i,j) != NULL);
+        MATELEM(C,nj,ni) = pPermPoly(MATELEM(src->GetNC()->C,i,j),perm,src,nMap,par_perm,src->P);
+
+        if(MATELEM(src->GetNC()->D,i,j) != NULL)
+          MATELEM(D,nj,ni) = pPermPoly(MATELEM(src->GetNC()->D,i,j),perm,src,nMap,par_perm,src->P);
+      }
+    }
+
+    idTest((ideal)C);
+    idTest((ideal)D);
+
+    if (nc_CallPlural(C, D, NULL, NULL, r, false, false, true, r))
+      WarnS("Error initializing non-commutative multiplication!");
+
+    assume( r->GetNC()->IsSkewConstant == src->GetNC()->IsSkewConstant);
+    assume( ncRingType(r) == ncRingType(src) );
+
+    omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
+
+    rChangeCurrRing(save); 
+  
+  }
+#endif /* HAVE_PLURAL */
+
+
   /* now oppose the qideal for qrings */
   if (src->qideal != NULL)
@@ -4244 +4445 @@
     idDelete(&(r->qideal));
     r->qideal = idOppose(src, src->qideal);
-  }
+
+#ifdef HAVE_PLURAL
+    if( rIsPluralRing(r) )
+      nc_SetupQuotient(r);
+#endif
+  }
+
   rTest(r);
+
   rChangeCurrRing(save);
-#endif /* HAVE_PLURAL */
   return r;
 }
@@ -4263 +4470 @@
   return Renv;
 }
+
 #ifdef HAVE_PLURAL
-BOOLEAN nc_rComplete(ring src, ring dest)
+BOOLEAN nc_rComplete(const ring src, ring dest, bool bSetupQuotient) 
 /* returns TRUE is there were errors */
 /* dest is actualy equals src with the different ordering */
 /* we map src->nc correctly to dest->src */
 /* to be executed after rComplete, before rChangeCurrRing */
-
-{
+{
+// NOTE: Originally used only by idElimination to transfer NC structure to dest
+// ring created by dirty hack (without nc_CallPlural)
+
+  assume(!rIsPluralRing(dest)); // destination must be a newly constructed commutative ring 
+
   if (!rIsPluralRing(src))
+  {
     return FALSE;
-  int i,j;
-  int N = dest->N;
-  if (src->N != N)
-  {
-    /* should not happen */
-    WarnS("wrong nc_rComplete call");
-    return TRUE;
-  }
+  }
+
+  const int N = dest->N;
+
+  assume(src->N == N);
+
   ring save = currRing;
-  int WeChangeRing = 0;
-  if (dest != currRing)
-  {
-    WeChangeRing = 1;
+
+  if (dest != save)
     rChangeCurrRing(dest);
-  }
-  matrix C = mpNew(N,N);
+
+  const ring srcBase = src->GetNC()->basering;
+  
+  assume( nSetMap(srcBase) == nSetMap(currRing) ); // currRing is important here!
+  
+  matrix C = mpNew(N,N); // ring independent
   matrix D = mpNew(N,N);
-  matrix C0 = src->nc->C;
-  matrix D0 = src->nc->D;
+
+  matrix C0 = src->GetNC()->C;
+  matrix D0 = src->GetNC()->D;
+
+
   poly p = NULL;
   number n = NULL;
-  for (i=1; i< N; i++)
-  {
-    for (j= i+1; j<= N; j++)
-    {
-      n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), src),src);
-      p = p_ISet(1,dest);
-      p_SetCoeff(p,n,dest);
+
+  // map C and D into dest
+  for (int i = 1; i < N; i++)
+  {
+    for (int j = i + 1; j <= N; j++)
+    {
+      const number n = n_Copy(p_GetCoeff(MATELEM(C0,i,j), srcBase), srcBase); // src, mapping for coeffs into currRing = dest!
+      const poly   p = p_NSet(n, dest);
       MATELEM(C,i,j) = p;
-      p = NULL;
       if (MATELEM(D0,i,j) != NULL)
-      {
-        p = prCopyR(MATELEM(D0,i,j), src->nc->basering, dest);
-        MATELEM(D,i,j) = nc_p_CopyPut(p, dest);
-        p_Delete(&p, dest);
-        p = NULL;
-      }
-    }
-  }
-  /* One must test C and D _only_ in r->nc->basering!!! not in r!!! */
-  //  idTest((ideal)C);
-  //  idTest((ideal)D);
-  id_Delete((ideal *)&(dest->nc->C),dest->nc->basering);
-  id_Delete((ideal *)&(dest->nc->D),dest->nc->basering);
-  dest->nc->C = C;
-  dest->nc->D = D;
-  if ( WeChangeRing )
+        MATELEM(D,i,j) = prCopyR(MATELEM(D0,i,j), srcBase, dest); // ? 
+    }
+  }
+  /* One must test C and D _only_ in r->GetNC()->basering!!! not in r!!! */
+  
+  idTest((ideal)C); // in dest!
+  idTest((ideal)D);
+
+  if (nc_CallPlural(C, D, NULL, NULL, dest, bSetupQuotient, false, true, dest)) // also takes care about quotient ideal
+  {
+    WarnS("Error transferring non-commutative structure");
+
+    mpDelete(&C, dest);
+    mpDelete(&D, dest);
+
+    return TRUE;
+  }
+  
+//  mpDelete(&C, dest); // used by nc_CallPlural!
+//  mpDelete(&D, dest);
+
+  if (dest != save)
     rChangeCurrRing(save);
-  if (nc_InitMultiplication(dest))
-  {
-    WarnS("Error initializing multiplication!");
-    return TRUE;
-  }
+  
   return FALSE;
 }

kernel/ring.h

@@ -7 +7 @@
 * ABSTRACT - the interpreter related ring operations
 */
-/* $Id: ring.h,v 1.28 2008-04-21 11:23:12 Singular Exp $ */
+/* $Id: ring.h,v 1.29 2008-06-10 10:17:33 motsak Exp $ */
 
 /* includes */
@@ -37 +37 @@
 {
 #ifdef HAVE_PLURAL
-  return (r != NULL) && (r->nc != NULL) && (r->nc->type != nc_error); 
+  return (r != NULL) && (r->GetNC() != NULL) && (r->GetNC()->type != nc_error); 
 #else
   return false;
@@ -247 +247 @@
 // use this to free fields created by rComplete
 
-BOOLEAN nc_rComplete(ring src, ring dest);
-
-void rUnComplete(ring r);
 inline int rBlocks(ring r)
 {
@@ -379 +376 @@
 void rDebugPrint(ring r);
 void pDebugPrint(poly p);
+void pDebugPrintR(poly p, const ring r);
 
 int64 * rGetWeightVec(ring r);

kernel/sca.cc

@@ -7 +7 @@
  *  Author:  motsak (Oleksandr Motsak)
  *  Created: 2006/12/18
- *  Version: $Id: sca.cc,v 1.15 2008-05-15 17:24:36 motsak Exp $
+ *  Version: $Id: sca.cc,v 1.16 2008-06-10 10:17:33 motsak Exp $
  *******************************************************************/
+
+#define OM_CHECK 4
+#define OM_TRACK 5
 
 // #define PDEBUG 2
@@ -17 +20 @@
 #define PLURAL_INTERNAL_DECLARATIONS
 #include "sca.h"
+#include "gring.h"
 
 
@@ -384 +388 @@
       if(iComponentMonomM==0 )
       {
-        WarnS("Multiplication in the left module from the right");
+        WarnS("sca_p_Mult_mm: Multiplication in the left module from the right");
       }
 #endif
@@ -466 +470 @@
       if(iComponentMonomM==0 )
       {
-        WarnS("Multiplication in the left module from the right");
+        WarnS("sca_pp_Mult_mm: Multiplication in the left module from the right");
       }
 #endif
@@ -576 +580 @@
       if(iComponent==0 )
       {
-        WarnS("Multiplication in the left module from the right");
+        WarnS("sca_mm_Mult_pp: Multiplication in the left module from the right!");
+//        PrintS("mm = "); p_Write(pMonom, rRing);
+//        PrintS("pp = "); p_Write(pPoly, rRing);
+//        assume(iComponent!=0);        
       }
 #endif
@@ -637 +644 @@
     if( iComponentMonomM!=0 )
     {
-      if( iComponent!=0 ) // TODO: make global if on iComponentMonomM =?= 0
+      if( iComponent!=0 ) 
       {
         // REPORT_ERROR
@@ -647 +654 @@
       }
 #ifdef PDEBUG
-      if(iComponent==0 )
+      if(iComponent==0)
       {
-        WarnS("Multiplication in the left module from the right");
+        WarnS("sca_mm_Mult_p: Multiplication in the left module from the right!");
+//        PrintS("mm = "); p_Write(pMonom, rRing);
+//        PrintS("p = "); p_Write(pPoly, rRing);
+//        assume(iComponent!=0);        
       }
 #endif
@@ -700 +710 @@
 
 // GB computation routines:
-
-/*2
-* returns the LCM of the head terms of a and b
-*/
-inline poly p_Lcm(const poly a, const poly b, const long lCompM, const ring r)
-{
-  poly m = p_ISet(1, r);
-
-  const int N = r->N;
-
-  for (int i = N; i>0; i--)
-  {
-    const int lExpA = p_GetExp (a, i, r);
-    const int lExpB = p_GetExp (b, i, r);
-
-    p_SetExp (m, i, si_max(lExpA, lExpB), r);
-  }
-
-  p_SetComp (m, lCompM, r);
-
-  p_Setm(m,r);
-
-#ifdef PDEBUG
-  p_Test(m,r);
-#endif
-
-  return(m);
-}
 
 /*4
@@ -970 +952 @@
 #endif
 
+#define OUTPUT 0
 
 
@@ -975 +958 @@
 {
 #if MYTEST
-   PrintS("<sca_gr_bba>\n");
+//   PrintS("<sca_gr_bba>\n");
 #endif
 
@@ -985 +968 @@
 #endif
 
+#ifdef HAVE_PLURAL
+#if MYTEST
+  PrintS("currRing: \n");
+  rWrite(currRing);
+#ifdef RDEBUG
+  rDebugPrint(currRing);
+#endif
+
+  PrintS("F: \n");
+  idPrint(F);  
+  PrintS("Q: \n");  
+  idPrint(Q);
+#endif
+#endif
+
+  
   const unsigned int m_iFirstAltVar = scaFirstAltVar(currRing);
   const unsigned int m_iLastAltVar  = scaLastAltVar(currRing);
@@ -992 +991 @@
 
   if(Q == currQuotient)
-    tempQ = currRing->nc->SCAQuotient();
+    tempQ = SCAQuotient(currRing);
 
   bool bIdHomog = id_IsSCAHomogeneous(tempF, NULL, NULL, currRing); // wCx == wCy == NULL!
@@ -1000 +999 @@
   strat->homog = strat->homog && bIdHomog;
 
-
   assume( strat->homog == bIdHomog );
 
-
 #if MYTEST
-/*
-  {
-    Print("ideal F: \n");
-    idPrint(F);
+  {
     Print("ideal tempF: \n");
-    idPrint(F);
-  }
-*/
-#endif
-
-
-
-
+    idPrint(tempF);
+    Print("ideal tempQ: \n");
+    idPrint(tempQ);
+  }
+#endif
 
   int srmax, lrmax;
@@ -1034 +1025 @@
   // ?? set spSpolyShort, reduce ???
 
-  initBuchMora(tempF, tempQ, strat); // currRing->nc->SCAQuotient() instead of Q == squares!!!!!!!
+  initBuchMora(tempF, tempQ, strat); // SCAQuotient(currRing) instead of Q == squares!!!!!!!
 
   strat->posInT=posInT110; // !!!
@@ -1076 +1067 @@
     //kTest(strat);
 
-    assume(pNext(strat->P.p) != strat->tail);
-
-//     if( pNext(strat->P.p) == strat->tail )
-//     {
-//       // deletes the int spoly and computes SPoly
-//       pLmFree(strat->P.p); // ???
-//       strat->P.p = sca_SPoly(strat->P.p1, strat->P.p2, currRing);
-//     }
+//    assume(pNext(strat->P.p) != strat->tail); // !???
+    if(strat->P.IsNull()) continue;
+
+    
+    if( pNext(strat->P.p) == strat->tail )
+    {
+      // deletes the int spoly and computes SPoly
+      pLmFree(strat->P.p); // ???
+      strat->P.p = nc_CreateSpoly(strat->P.p1, strat->P.p2, currRing);
+    }
 
     if(strat->P.IsNull()) continue;
@@ -1222 +1215 @@
 
 #if MYTEST
-   PrintS("</sca_gr_bba>\n");
+//   PrintS("</sca_gr_bba>\n");
 #endif
 
@@ -1236 +1229 @@
 // if yes, make rGR a super-commutative algebra!
 // NOTE: Factors of SuperCommutative Algebras are supported this way!
-bool sca_SetupQuotient(ring rGR, const ring rG)
+//
+//  rG == NULL means that there is no separate base G-algebra in this case take rGR == rG
+bool sca_SetupQuotient(ring rGR, ring rG)
 {
 //   return false; // test Plural
@@ -1243 +1238 @@
   // checks...
   //////////////////////////////////////////////////////////////////////////
+  if( rG == NULL ) 
+    rG = rGR;
+
   assume(rGR != NULL);
   assume(rG  != NULL);
-
   assume(rIsPluralRing(rG));
+  
+
+#if MYTEST
+   PrintS("sca_SetupQuotient(rGR, rG)");
+#endif
 
   const int N = rG->N;
@@ -1253 +1255 @@
     return false;
 
-#if MYTEST
-   PrintS("sca_SetupQuotient(rGR, rG)");
-#endif
-
-
+  
 //  if( (ncRingType(rG) != nc_skew) || (ncRingType(rG) != nc_comm) )
 //    return false;
 
+#if OUTPUT
+  PrintS("sca_SetupQuotient: qring?\n");
+#endif
+
   if(rGR->qideal == NULL) // there will be a factor!
     return false;
 
-  if(rG->qideal != NULL) // we cannot change from factor to factor!
+#if OUTPUT
+  PrintS("sca_SetupQuotient: qideal!!!\n");
+#endif
+  
+  if((rG->qideal != NULL) && (rG != rGR) ) // we cannot change from factor to factor at the time, sorry!
     return false;
 
@@ -1271 +1277 @@
   int iAltVarStart   = N+1;
 
-  const ring rBase = rG->nc->basering;
-  const matrix C   = rG->nc->C; // live in rBase!
-
+  const ring rBase = rG->GetNC()->basering;
+  const matrix C   = rG->GetNC()->C; // live in rBase!
+
+#if OUTPUT
+  PrintS("sca_SetupQuotient: AltVars?!\n");
+#endif
+  
   for(int i = 1; i < N; i++)
   {
@@ -1292 +1302 @@
         if( !n_IsOne(c, rBase) )
         {
+#if OUTPUT
+          Print("Wrong Coeff at: [%d, %d]\n", i, j);
+#endif
 #if MYTEST
            Print("Wrong Coeff at: [%d, %d]\n", i, j);
@@ -1301 +1314 @@
   }
 
+#if MYTEST
+  Print("AltVars?1: [%d, %d]\n", iAltVarStart, iAltVarEnd);
+#endif
+
+  
   if( (iAltVarEnd == -1) || (iAltVarStart == (N+1)) )
     return false; // either no alternating varables, or a single one => we are in commutative case!
 
+  
   for(int i = 1; i < N; i++)
   {
@@ -1315 +1334 @@
         if( !n_IsMOne(c, rBase) )
         {
+#ifdef PDEBUG
+#if OUTPUT
+           Print("Wrong Coeff at: [%d, %d]\n", i, j);
+#endif
+#endif
+
 #if MYTEST
            Print("Wrong Coeff at: [%d, %d]\n", i, j);
@@ -1324 +1349 @@
         if( !n_IsOne(c, rBase) )
         {
+#ifdef PDEBUG
+#if OUTPUT
+          Print("Wrong Coeff at: [%d, %d]\n", i, j);
+#endif
+#endif
 #if MYTEST
            Print("Wrong Coeff at: [%d, %d]\n", i, j);
@@ -1333 +1363 @@
   }
 
+#if MYTEST
+  Print("AltVars!?: [%d, %d]\n", iAltVarStart, iAltVarEnd);
+#endif
+
   assume( 1            <= iAltVarStart );
   assume( iAltVarStart < iAltVarEnd   );
   assume( iAltVarEnd   <= N            );
 
+
+
   bool bWeChangeRing = false;
   // for sanity
@@ -1347 +1383 @@
   }
 
+  
   assume(rGR->qideal != NULL);
-  assume(rG->qideal == NULL);
+//  assume(rG->qideal == NULL); // ?
 
   const ideal idQuotient = rGR->qideal;
 
+
+#if MYTEST
+  Print("Analyzing quotient ideal:\n");
+  idPrint(idQuotient); // in rG!!!
+#endif
+
+  
   // check for
   // y_{iAltVarStart}^2, y_{iAltVarStart+1}^2, \ldots, y_{iAltVarEnd}^2  (iAltVarEnd > iAltVarStart)
@@ -1360 +1404 @@
   for ( int i = iAltVarStart; (i <= iAltVarEnd) && bSCA; i++ )
   {
-    poly square = p_ISet(1, rSaveRing);
-    p_SetExp(square, i, 2, rSaveRing); // square = var(i)^2.
-    p_Setm(square, rSaveRing);
+    poly square = p_ISet(1, rG);
+    p_SetExp(square, i, 2, rG); // square = var(i)^2.
+    p_Setm(square, rG);
 
     // square = NF( var(i)^2 | Q )
     // NOTE: rSaveRing == currRing now!
     // NOTE: there is no better way to check this in general!
-    square = kNF(idQuotient, NULL, square, 0, 0);
+    square = kNF(idQuotient, NULL, square, 0, 0); // must ran in currRing == rG!
 
     if( square != NULL ) // var(i)^2 is not in Q?
     {
-      p_Delete(&square, rSaveRing);
+      p_Delete(&square, rG);
       bSCA = false;
     }
@@ -1385 +1429 @@
 
 
-
-#if MYTEST
-  Print("AltVars: [%d, %d]\n", iAltVarStart, iAltVarEnd);
-#endif
-
+#ifdef PDEBUG
+#if OUTPUT
+  Print("ScaVars!: [%d, %d]\n", iAltVarStart, iAltVarEnd);
+#endif
+#endif
+  
 
   //////////////////////////////////////////////////////////////////////////
@@ -1399 +1444 @@
 
   if( idIs0(tempQ) )
-    rGR->nc->SCAQuotient() = NULL;
+    rGR->GetNC()->SCAQuotient() = NULL;
   else
-    rGR->nc->SCAQuotient() = idrMoveR(tempQ, rG, rGR); // deletes tempQ!
+    rGR->GetNC()->SCAQuotient() = idrMoveR(tempQ, rG, rGR); // deletes tempQ!
 
   ncRingType( rGR, nc_exterior );
@@ -1409 +1454 @@
 
 
-  sca_p_ProcsSet(rGR, rGR->p_Procs);
-
+  nc_p_ProcsSet(rGR, rGR->p_Procs); // !!!!!!!!!!!!!!!!!
 
   return true;
@@ -1440 +1484 @@
 
   if( idIs0(tempQ) )
-    rGR->nc->SCAQuotient() = NULL;
+    rGR->GetNC()->SCAQuotient() = NULL;
   else
-    rGR->nc->SCAQuotient() = tempQ;
+    rGR->GetNC()->SCAQuotient() = tempQ;
   
   ncRingType( rGR, nc_exterior );
@@ -1450 +1494 @@
 
 
-  sca_p_ProcsSet(rGR, rGR->p_Procs);
+  nc_p_ProcsSet(rGR, rGR->p_Procs);
 
   if(rSaveRing != rGR)
@@ -1500 +1544 @@
 
   if(Q == currQuotient)
-    tempQ = currRing->nc->SCAQuotient();
+    tempQ = SCAQuotient(currRing);
 
   // Q or tempQ will not be used below :(((
@@ -1603 +1647 @@
 
 
-    assume(pNext(strat->P.p) != strat->tail);
-
-/*    if (pNext(strat->P.p) == strat->tail)
+//    assume(pNext(strat->P.p) != strat->tail);
+
+    if(strat->P.IsNull()) continue;
+
+    if (pNext(strat->P.p) == strat->tail)
     {
       // deletes the short spoly
       pLmFree(strat->P.p);
+
+      strat->P.p = nc_CreateSpoly(strat->P.p1, strat->P.p2, currRing);
+
+/*      
       strat->P.p = NULL;
+
+
       poly m1 = NULL, m2 = NULL;
 
@@ -1629 +1681 @@
       ksCreateSpoly(&(strat->P), NULL, strat->use_buckets,
                     strat->tailRing, m1, m2, strat->R); //?????????
-    }
-    else */
+*/                    
+    }//    else
 
     if (strat->P.p1 == NULL)
@@ -1920 +1972 @@
 
   if(Q == currQuotient)
-    tempQ = currRing->nc->SCAQuotient();
+    tempQ = SCAQuotient(currRing);
 
   bool bIdHomog = id_IsSCAHomogeneous(tempF, NULL, NULL, currRing); // wCx == wCy == NULL!
@@ -2028 +2080 @@
 
     // create the real Spoly
-    assume(pNext(strat->P.p) != strat->tail);
+//    assume(pNext(strat->P.p) != strat->tail);
+
+    if(strat->P.IsNull()) continue;
+
+
+    if( pNext(strat->P.p) == strat->tail )
+    {
+      // deletes the int spoly and computes SPoly
+      pLmFree(strat->P.p); // ???
+      strat->P.p = nc_CreateSpoly(strat->P.p1, strat->P.p2, currRing);
+    }
+    
+    
 
     if (strat->P.p1 == NULL)
@@ -2203 +2267 @@
 
   // non-commutaitve
-  rGR->nc->p_Procs.mm_Mult_p   = sca_mm_Mult_p;
-  rGR->nc->p_Procs.mm_Mult_pp  = sca_mm_Mult_pp;
+  rGR->GetNC()->p_Procs.mm_Mult_p   = sca_mm_Mult_p;
+  rGR->GetNC()->p_Procs.mm_Mult_pp  = sca_mm_Mult_pp;
 
 
@@ -2212 +2276 @@
 //           Print("Local case => GB == mora!\n");
 #endif
-    rGR->nc->p_Procs.GB          = sca_mora; // local ordering => Mora, otherwise - Buchberger!
+    rGR->GetNC()->p_Procs.GB          = sca_mora; // local ordering => Mora, otherwise - Buchberger!
   }
   else
@@ -2219 +2283 @@
 //           Print("Global case => GB == bba!\n");
 #endif
-    rGR->nc->p_Procs.GB          = sca_gr_bba; // sca_bba?
-  }
-
-
-//   rGR->nc->p_Procs.GlobalGB    = sca_gr_bba;
-//   rGR->nc->p_Procs.LocalGB     = sca_mora;
-
-
-//   rGR->nc->p_Procs.SPoly         = sca_SPoly;
-//   rGR->nc->p_Procs.ReduceSPoly   = sca_ReduceSpoly;
+    rGR->GetNC()->p_Procs.GB          = sca_bba; // sca_gr_bba; // sca_bba? // sca_bba;
+  }
+
+
+//   rGR->GetNC()->p_Procs.GlobalGB    = sca_gr_bba;
+//   rGR->GetNC()->p_Procs.LocalGB     = sca_mora;
+
+
+//   rGR->GetNC()->p_Procs.SPoly         = sca_SPoly;
+//   rGR->GetNC()->p_Procs.ReduceSPoly   = sca_ReduceSpoly;
 
 #if 0
@@ -2240 +2304 @@
         _p_procs->pp_Mult_mm = sca_pp_Mult_mm;
 
-        r->nc->mmMultP()     = sca_mm_Mult_p;
-        r->nc->mmMultPP()    = sca_mm_Mult_pp;
-
-        r->nc->GB()            = sca_gr_bba;
+        r->GetNC()->mmMultP()     = sca_mm_Mult_p;
+        r->GetNC()->mmMultPP()    = sca_mm_Mult_pp;
+
+        r->GetNC()->GB()            = sca_gr_bba;
 /*
         // ??????????????????????????????????????? coefficients swell...
-        r->nc->SPoly()         = sca_SPoly;
-        r->nc->ReduceSPoly()   = sca_ReduceSpoly;
+        r->GetNC()->SPoly()         = sca_SPoly;
+        r->GetNC()->ReduceSPoly()   = sca_ReduceSpoly;
 */
-//         r->nc->BucketPolyRed() = gnc_kBucketPolyRed;
-//         r->nc->BucketPolyRed_Z()= gnc_kBucketPolyRed_Z;
+//         r->GetNC()->BucketPolyRed() = gnc_kBucketPolyRed;
+//         r->GetNC()->BucketPolyRed_Z()= gnc_kBucketPolyRed_Z;
 
 #endif

kernel/sca.h

@@ -5 +5 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: sca.h,v 1.11 2008-05-15 17:24:37 motsak Exp $ */
+/* $Id: sca.h,v 1.12 2008-06-10 10:17:33 motsak Exp $ */
 
 #include <ring.h>
@@ -32 +32 @@
   // SCA!
 #ifdef HAVE_PLURAL
-  return r->nc->SCAQuotient();
+  return r->GetNC()->SCAQuotient();
 #else
   // for sainity
@@ -48 +48 @@
   assume(rIsSCA(r));
 
-  return (r->nc->FirstAltVar());
+  return (r->GetNC()->FirstAltVar());
 };
 
@@ -55 +55 @@
   assume(rIsSCA(r));
 
-  return (r->nc->LastAltVar());
+  return (r->GetNC()->LastAltVar());
 };
 
@@ -64 +64 @@
   assume(rIsSCA(r));
 
-  r->nc->FirstAltVar() = n;
+  r->GetNC()->FirstAltVar() = n;
 };
 
@@ -71 +71 @@
   assume(rIsSCA(r));
 
-  r->nc->LastAltVar() = n;
+  r->GetNC()->LastAltVar() = n;
 };
 
@@ -184 +184 @@
 // should be used only inside nc_SetupQuotient!
 // Check whether this our case:
-//  1. rG is  a commutative polynomial ring \otimes anticommutative algebra
+//  1. rG is  a commutative polynomial ring \otimes anticommutative algebra 
 //  2. factor ideal rGR->qideal contains squares of all alternating variables.
 // 
 // if yes, make rGR a super-commutative algebra!
 // NOTE: Factors of SuperCommutative Algebras are supported this way!
-bool sca_SetupQuotient(ring rGR, const ring rG);
+//
+//  rG == NULL means that there is no separate base G-algebra in this case take rGR == rG
+bool sca_SetupQuotient(ring rGR, ring rG);
 
 #endif // PLURAL_INTERNAL_DECLARATIONS

kernel/structs.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: structs.h,v 1.44 2008-05-09 09:17:57 Singular Exp $ */
+/* $Id: structs.h,v 1.45 2008-06-10 10:17:33 motsak Exp $ */
 /*
 * ABSTRACT
@@ -474 +474 @@
   int *MTsize; // size 0.. (rVar()*rVar()-1)/2
 
-  // IsSkewConstantindicates whethere coeffs C_ij are all equal, effective together with nc_type=nc_skew
+  // IsSkewConstant indicates whethere coeffs C_ij are all equal, 
+  // effective together with nc_type=nc_skew
   int IsSkewConstant;
 
@@ -631 +632 @@
   ring          algring;
 #ifdef HAVE_PLURAL
-  nc_struct     *nc;
+  private:
+    nc_struct*    _nc; // private
+  public:
+    inline const nc_struct* GetNC() const { return _nc; }; // public!!!
+    inline nc_struct*& GetNC() { return _nc; }; // public!!!
 #endif
 };

kernel/syz.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: syz.cc,v 1.12 2007-02-02 15:19:46 motsak Exp $ */
+/* $Id: syz.cc,v 1.13 2008-06-10 10:17:33 motsak Exp $ */
 
 /*
@@ -621 +621 @@
   if( rIsSCA(currRing) )
   {
-    currQuotient = currRing->nc->SCAQuotient();
+    currQuotient = SCAQuotient(currRing);
     currRing->qideal = currQuotient;