===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2018/engine/dist.c,v
retrieving revision 1.2
retrieving revision 1.15
diff -u -p -r1.2 -r1.15
--- OpenXM_contrib2/asir2018/engine/dist.c	2018/09/28 08:20:28	1.2
+++ OpenXM_contrib2/asir2018/engine/dist.c	2019/11/19 10:50:31	1.15
@@ -45,7 +45,7 @@
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *
- * $OpenXM: OpenXM_contrib2/asir2018/engine/dist.c,v 1.1 2018/09/19 05:45:07 noro Exp $
+ * $OpenXM: OpenXM_contrib2/asir2018/engine/dist.c,v 1.14 2019/11/12 22:27:04 noro Exp $
 */
 #include "ca.h"
 
@@ -208,18 +208,8 @@ void initd(struct order_spec *spec)
   dp_current_spec = spec;
 }
 
-int dpm_ispot;
+int dpm_ordtype;
 
-/* type=0 => TOP, type=1 => POT */
-void initdpm(struct order_spec *spec,int type)
-{
-  int len,i,k,row;
-    Q **mat;
-
-  initd(spec);
-  dpm_ispot = type;
-}
-
 void ptod(VL vl,VL dvl,P p,DP *pr)
 {
   int n,i,j,k;
@@ -343,7 +333,7 @@ void nodetod(NODE node,DP *dp)
 void nodetodpm(NODE node,Obj pos,DPM *dp)
 {
   NODE t;
-  int len,i,td;
+  int len,i,td,p;
   Q e;
   DL d;
   DMM m;
@@ -362,7 +352,13 @@ void nodetodpm(NODE node,Obj pos,DPM *dp)
     }
   }
   d->td = td;
-  NEWDMM(m); m->dl = d; m->pos = ZTOS((Q)pos); C(m) = (Obj)ONE; NEXT(m) = 0;
+  p = ZTOS((Q)pos);
+  if ( dp_current_spec->module_rank ) {
+    if ( p > dp_current_spec->module_rank )
+      error("nodetodpm : inconsistent order spec");
+    d->td += dp_current_spec->module_top_weight[p-1];
+  }
+  NEWDMM(m); m->dl = d; m->pos = p; C(m) = (Obj)ONE; NEXT(m) = 0;
   MKDPM(len,m,u); u->sugar = td; *dp = u;
 }
 
@@ -370,12 +366,20 @@ void dtodpm(DP d,int pos,DPM *dp)
 {
   DMM mr0,mr;
   MP m;
+  int shift;
 
   if ( !d ) *dp = 0;
   else {
+    shift = 0;
+    if ( dp_current_spec->module_rank ) {
+      if ( pos > dp_current_spec->module_rank )
+        error("nodetodpm : inconsistent order spec");
+      shift = dp_current_spec->module_top_weight[pos-1];
+    } 
     for ( m = BDY(d), mr0 = 0; m; m = NEXT(m) ) {
       NEXTDMM(mr0,mr);
       mr->dl = m->dl;
+      mr->dl->td += shift;
       mr->pos = pos;
       C(mr) = C(m);
     }
@@ -578,6 +582,34 @@ void _adddl(int n,DL d1,DL d2,DL d3)
     d3->d[i] = d1->d[i]+d2->d[i];
 }
 
+void _addtodl(int n,DL d1,DL d2)
+{
+  int i;
+
+  d2->td += d1->td;
+  for ( i = 0; i < n; i++ )
+    d2->d[i] += d1->d[i];
+}
+
+void _copydl(int n,DL d1,DL d2)
+{
+  int i;
+
+  d2->td = d1->td;
+  for ( i = 0; i < n; i++ )
+    d2->d[i] = d1->d[i];
+}
+
+int _eqdl(int n,DL d1,DL d2)
+{
+  int i;
+
+  if ( d2->td != d1->td ) return 0;
+  for ( i = 0; i < n; i++ )
+    if ( d2->d[i] != d1->d[i] ) return 0;
+  return 1;
+}
+
 /* m1 <- m1 U dl*f, destructive */
 
 NODE mul_dllist(DL dl,DP f);
@@ -2616,26 +2648,429 @@ NBP harmonic_mul_nbm(NBM a,NBM b)
 
 /* DPM functions */
 
+DMMstack dmm_stack;
+int dpm_base_ordtype;;
+
+DMMstack push_schreyer_order(LIST data,DMMstack stack)
+{
+  DMMstack t;
+  DP dp;
+  MP mp;
+  DMM m0,m1;
+  DPM dpm0,dpm1;
+  int len,i,nv;
+  NODE in,t1;
+  LIST l;
+
+  /* data = [DPM,...,DPM] */
+  if ( !dmm_stack && ( !dp_current_spec || dp_current_spec->id < 256 ) )
+      error("push_schreyer_order : base module order is not set");
+  in = BDY(data);
+  len = length(in);
+  NEWDMMstack(t);
+  t->rank = len;
+  t->in = (DMM *)MALLOC((len+1)*sizeof(DMM));
+  t->sum = (DMM *)MALLOC((len+1)*sizeof(DMM));
+  if ( stack ) {
+    MKNODE(t1,data,BDY(stack->obj)); MKLIST(l,t1); t->obj = l;
+    for ( i = 1; i <= len; i++, in = NEXT(in) ) {
+       m1 = t->in[i] = BDY((DPM)BDY(in));
+       NEWMP(mp); mp->dl = m1->dl; mp->c = m1->c; NEXT(mp) = 0;
+       nv = ((DPM)BDY(in))->nv;
+       MKDP(nv,mp,dp); dp->sugar = mp->dl->td;
+       m0 = stack->sum[m1->pos]; MKDPM(nv,m0,dpm0);
+       mulobjdpm(CO,(Obj)dp,dpm0,&dpm1);
+       t->sum[i] = BDY(dpm1);
+    }
+  } else {
+    MKNODE(t1,data,0); MKLIST(l,t1); t->obj = l;
+    for ( i = 1; i <= len; i++, in = NEXT(in) ) {
+      t->sum[i] = t->in[i] = BDY((DPM)BDY(in));
+    }
+  }
+  t->next = stack;;
+  dpm_ordtype = 3;
+  return t;
+}
+
+// data=[Ink,...,In0]
+// Ini = a list of module monomials
+
+void set_schreyer_order(LIST data)
+{
+  NODE in;
+  LIST *w;
+  int i,len;
+
+  if ( !data ) {
+    dmm_stack = 0;
+    if ( dp_current_spec && dp_current_spec->id >= 256 )
+      dpm_ordtype = dp_current_spec->module_ordtype;
+    else 
+      dpm_ordtype = 0;
+    return;
+  } else {
+    if ( !dp_current_spec || dp_current_spec->id < 256 )
+      error("set_schreyer_order : base module order is not set");
+    dmm_stack = 0;
+    dpm_base_ordtype = dp_current_spec->module_ordtype;
+    in = BDY(data);
+    len = length(in);
+    w = (LIST *)MALLOC(len*sizeof(LIST));
+    for ( i = 0; i < len; i++, in = NEXT(in) ) w[i] = (LIST)BDY(in);
+    for ( i = len-1; i >= 0; i-- ) dmm_stack = push_schreyer_order(w[i],dmm_stack);
+  }
+}
+
+void set_schreyer_level(DMMstack_array array,int level)
+{
+  if ( !level ) {
+    dmm_stack = 0;
+    if ( dp_current_spec && dp_current_spec->id >= 256 )
+      dpm_ordtype = dp_current_spec->module_ordtype;
+    else 
+      dpm_ordtype = 0;
+    return;
+  } else {
+    if ( !dp_current_spec || dp_current_spec->id < 256 )
+      error("set_schreyer_level : base module order is not set");
+    if ( level > array->len )
+      error("set_schreyer_level : invalid level");
+    dmm_stack = array->body[level-1];
+    dpm_base_ordtype = dp_current_spec->module_ordtype;
+    dpm_ordtype = 3;
+  }
+}
+
+// construct a base of syz(g) 
+// assuming the schrerer order is properly set
+
+DP dpm_sp_hm(DPM p1,DPM p2);
+void dpm_sp(DPM p1,DPM p2,DPM *sp,DP *t1,DP *t2);
+DPM dpm_nf_and_quotient3(DPM sp,VECT psv,DPM *nf,P *dn);
+DPM dpm_nf_and_quotient4(DPM sp,DPM *ps,VECT psiv,DPM head,DPM *nf,P *dn);
+DPM dpm_sp_nf(VECT psv,VECT psiv,int i,int j,DPM *nf);
+DPM dpm_sp_nf_asir(VECT psv,int i,int j,DPM *nf);
+void dpm_sort(DPM p,DPM *r);
+
+extern int DP_Multiple;
+
+void dpm_nf_z(NODE b,DPM g,VECT psv,int full,int multiple,DPM *rp);
+NODE dpm_sort_list(NODE l);
+void dpm_ptozp(DPM p,Z *cont,DPM *r);
+
+NODE dpm_reduceall(NODE in)
+{
+  int n,i;
+  VECT psv;
+  DPM *ps;
+  NODE t,t1;
+  DPM g,r;
+  Z cont;
+
+  n = length(in);
+  MKVECT(psv,n);
+  ps = (DPM *)BDY(psv);
+  for ( i = 0, t = in; i < n; i++, t = NEXT(t) ) ps[i] = BDY(t);
+  for ( i = 0; i < n; i++ ) {
+    g = ps[i]; ps[i] = 0;
+//    dpm_nf_z(0,g,psv,1,DP_Multiple,&ps[i]);
+    dpm_nf_z(0,g,psv,1,0,&ps[i]);
+  }
+  t = 0;
+  for ( i = n-1; i >= 0; i-- ) {
+    dpm_ptozp(ps[i],&cont,&r);
+    MKNODE(t1,r,t); t = t1;
+  }
+  return t;
+}
+
+struct oEGT egra;
+
+void dpm_ht(DPM d,DPM *r);
+
+void dpm_schreyer_base(LIST g,LIST *s)
+{
+  NODE nd,t0,t,b0,b;
+  int n,i,j,k,nv,max,pos;
+  LIST l;
+  DP h,t1,t2;
+  MP d;
+  DMM r0,r,r1;
+  DPM sp,nf,dpm;
+  DPM *ps;
+  VECT psv,psiv;
+  DPM quo;
+  DP **m;
+  NODE *psi;
+  NODE n1,n2,n3;
+  int p1,p2,p3;
+  struct oEGT eg0,eg1,egsp,egnf;
+  extern struct oEGT egred;
+  extern int sch_count,schrec_count,schlast_count;
+
+  sch_count = schlast_count= 0;
+  init_eg(&egra);
+  init_eg(&egsp);
+  init_eg(&egnf);
+  nd = BDY(g);
+  n = length(nd);
+  MKVECT(psv,n+1);
+  ps = (DPM *)BDY(psv);
+  for ( i = 1, t = nd; i <= n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);
+  for ( i = 1, max = 0; i <= n; i++ )
+    if ( (pos=BDY(ps[i])->pos) > max ) max = pos;
+  MKVECT(psiv,max+1);
+  psi = (NODE *)BDY(psiv);
+  for ( i = n; i >= 1; i-- ) {
+    pos = BDY(ps[i])->pos;
+    MKNODE(nd,(long)i,psi[pos]); psi[pos] = nd;
+  }
+  nv = ps[1]->nv;
+  m = (DP **)almat_pointer(n+1,n+1);
+  b0 = 0;
+  get_eg(&eg0);
+  for ( i = 1; i <= max; i++ ) {
+    for ( n1 = psi[i]; n1; n1 = NEXT(n1) ) {
+      p1 = (long)BDY(n1);
+      for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
+        p2 = (long)BDY(n2);
+        m[p1][p2] = dpm_sp_hm(ps[p1],ps[p2]);
+      }
+    }
+    for ( n1 = psi[i]; n1; n1 = NEXT(n1) ) {
+      p1 = (long)BDY(n1);
+      for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
+        p2 = (long)BDY(n2);
+        if ( !m[p1][p2] ) continue;
+        for ( h = m[p1][p2], n3 = NEXT(n1); n3; n3 = NEXT(n3) ) {
+          p3 = (long)BDY(n3);
+          if ( n3 != n2 && m[p1][p3] && dp_redble(m[p1][p3],h) ) m[p1][p3] = 0;
+        }
+      }
+    }
+  }
+  get_eg(&eg1); add_eg(&egsp,&eg0,&eg1); print_eg("SP",&egsp);
+  get_eg(&eg0);
+  for ( i = 1; i <= n; i++ ) {
+    for ( j = i+1; j <= n; j++ ) {
+      if ( m[i][j] ) {
+        quo = dpm_sp_nf(psv,psiv,i,j,&nf);
+        if ( nf ) 
+          error("dpm_schreyer_base : cannot happen");
+        NEXTNODE(b0,b); BDY(b) = (pointer)quo;
+      }
+    }
+  }
+  get_eg(&eg1); add_eg(&egnf,&eg0,&eg1); print_eg("NF",&egnf); printf("\n");
+  if ( b0 ) NEXT(b) = 0;
+  for ( t0 = t, nd = BDY(g); nd; nd = NEXT(nd) ) {
+    dpm_ht((DPM)BDY(nd),&dpm); NEXTNODE(t0,t); BDY(t) = (pointer)dpm;
+  }
+  if ( t0 ) NEXT(t) = 0;
+  MKLIST(l,t0);
+  dmm_stack = push_schreyer_order(l,dmm_stack);
+//  for ( t = b0; t; t = NEXT(t) ) {
+//    dpm_sort((DPM)BDY(t),&dpm); 
+//    BDY(t) = (pointer)dpm;
+//  }
+//    b0 = dpm_sort_list(b0);
+//  get_eg(&eg0);
+//  b0 = dpm_reduceall(b0);
+//  get_eg(&eg1); add_eg(&egra,&eg0,&eg1); print_eg("RA",&egra);
+  MKLIST(*s,b0);
+//  print_eg("red",&egred); printf("\n");
+  printf("sch_count=%d, schlast_count=%d\n",sch_count,schlast_count);
+}
+
+
+DMMstack_array dpm_schreyer_frame(NODE g)
+{
+  LIST l;
+  NODE nd,in,b0,b,n1,n2,n3,t;
+  NODE *psi;
+  long p1,p2,p3;
+  int nv,n,i,max,pos,level;
+  DMMstack s,s1;
+  DMM m1,m0,dmm;
+  MP mp;
+  DP dp,h;
+  DP *m;
+  DPM dpm,dpm0,dpm1;
+  VECT psv,psiv;
+  DPM *ps;
+  DMMstack_array dmmstack_array;
+
+  nd = g;
+  nv = ((DPM)BDY(nd))->nv;
+  s = 0;
+  level = 0;
+  while ( 1 ) {
+    /* store the current nd to a DMMstack */
+    n = length(nd);
+    NEWDMMstack(s1);
+    MKLIST(l,nd); s1->obj = l;
+    s1->rank = n;
+    s1->in = (DMM *)MALLOC((n+1)*sizeof(DMM));
+    s1->sum = (DMM *)MALLOC((n+1)*sizeof(DMM));
+    NEXT(s1) = s;
+    if ( s ) {
+      for ( i = 1, in = nd; i <= n; i++, in = NEXT(in) ) {
+        m1 = s1->in[i] = BDY((DPM)BDY(in));
+        NEWMP(mp); mp->dl = m1->dl; mp->c = m1->c; NEXT(mp) = 0;
+        MKDP(nv,mp,dp); dp->sugar = mp->dl->td;
+        m0 = s->sum[m1->pos]; MKDPM(nv,m0,dpm0);
+        mulobjdpm(CO,(Obj)dp,dpm0,&dpm1);
+        s1->sum[i] = BDY(dpm1);
+      }
+    } else {
+      for ( i = 1, in = nd; i <= n; i++, in = NEXT(in) ) 
+        s1->sum[i] = s1->in[i] = BDY((DPM)BDY(in));
+
+    }
+    s = s1;
+    level++;
+
+
+    /* create new list */
+    MKVECT(psv,n+1);
+    ps = (DPM *)BDY(psv);
+    for ( i = 1, t = nd; i <= n; i++, t = NEXT(t) ) ps[i] = (DPM)BDY(t);
+    for ( i = 1, max = 0; i <= n; i++ )
+      if ( (pos=BDY(ps[i])->pos) > max ) max = pos;
+    MKVECT(psiv,max+1);
+    psi = (NODE *)BDY(psiv);
+    for ( i = n; i >= 1; i-- ) {
+      pos = BDY(ps[i])->pos;
+      MKNODE(nd,(long)i,psi[pos]); psi[pos] = nd;
+    }
+    m = (DP *)MALLOC((n+1)*sizeof(DP));
+    b0 = 0;
+    for ( i = 1; i <= max; i++ ) {
+      for ( n1 = psi[i]; n1; n1 = NEXT(n1) ) {
+        bzero(m,(n+1)*sizeof(DP));
+        p1 = (long)BDY(n1);
+        for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
+          p2 = (long)BDY(n2);
+          h = dpm_sp_hm(ps[p1],ps[p2]);
+          for ( n3 = NEXT(n1); n3 != n2; n3 = NEXT(n3) ) {
+            p3 = (long)BDY(n3);
+            if ( m[p3] ) {
+              if ( dp_redble(h,m[p3]) ) {
+                h = 0; break;
+              }
+              if ( dp_redble(m[p3],h) ) m[p3] = 0;
+            }
+          }
+          if ( h ) m[p2] = h;
+        }
+        for ( n2 = NEXT(n1); n2; n2 = NEXT(n2) ) {
+          p2 = (long)BDY(n2);
+          if ( m[p2] ) {
+            NEWDMM(dmm); dmm->dl = BDY(m[p2])->dl; dmm->pos = p1; dmm->c = (Obj)ONE;
+            MKDPM(nv,dmm,dpm);
+            NEXTNODE(b0,b); BDY(b) = (pointer)dpm;
+          }
+        }
+      }
+    }
+    if ( !b0 ) {
+      NEWDMMstack_array(dmmstack_array);
+      dmmstack_array->len = level;
+      dmmstack_array->body = (DMMstack *)MALLOC(level*sizeof(DMMstack));
+      for ( i = level-1, s1 = s; i >= 0; i--, s1 = NEXT(s1) )
+        dmmstack_array->body[i] = s1;
+      return dmmstack_array;
+    } else {
+      NEXT(b) = 0;
+      nd = b0;
+    }
+  }
+}
+
+int sch_count,schlast_count;
+
+int compdmm_schreyer(int n,DMM m1,DMM m2)
+{
+  int pos1,pos2,t,npos1,npos2;
+  DMM *in,*sum;
+  DMMstack s;
+  static DL d1=0,d2=0;
+  static int dlen=0;
+
+  sch_count++;
+  pos1 = m1->pos; pos2 = m2->pos;
+  if ( pos1 == pos2 ) return (*cmpdl)(n,m1->dl,m2->dl);
+  if ( n > dlen ) {
+    NEWDL(d1,n); NEWDL(d2,n); dlen = n;
+  }
+  sum = dmm_stack->sum;
+  _adddl(n,m1->dl,sum[pos1]->dl,d1);
+  _adddl(n,m2->dl,sum[pos2]->dl,d2);
+  t = (*cmpdl)(n,d1,d2);
+  if ( sum[pos1]->pos == sum[pos2]->pos && t == 0 ) {
+    for ( s = dmm_stack; s; s = NEXT(s) ) {
+      in = s->in;
+      npos1 = in[pos1]->pos;
+      npos2 = in[pos2]->pos;
+      if ( npos1 == npos2 ) break;
+      else {
+        pos1 = npos1;
+        pos2 = npos2;
+      }
+    }
+    // (pos1,pos2) = the last pair s.t. pos1 != pos2
+    // simply compare pos1 and pos2
+    if ( pos1 < pos2 ) return 1;
+    else if ( pos1 > pos2 ) return -1;
+  } else {
+    schlast_count++;
+    pos1 = sum[pos1]->pos;
+    pos2 = sum[pos2]->pos;
+    if ( dpm_base_ordtype == 1 ) {
+      if ( pos1 < pos2 ) return 1;
+      else if ( pos1 > pos2 ) return -1;
+      else return t;
+    } else {
+      if ( t ) return t;
+      else if ( pos1 < pos2 ) return 1;
+      else if ( pos1 > pos2 ) return -1;
+      else return 0;
+    }
+  }
+}
+
 int compdmm(int n,DMM m1,DMM m2)
 {
   int t;
 
-  if ( dpm_ispot ) {
-    if ( m1->pos < m2->pos ) return 1;
-    else if ( m1->pos > m2->pos ) return -1;
-    else return (*cmpdl)(n,m1->dl,m2->dl);
-  } else {
+  switch ( dpm_ordtype ) {
+  case 0: /* TOP ord->pos */
     t = (*cmpdl)(n,m1->dl,m2->dl);
     if ( t ) return t;
     else if ( m1->pos < m2->pos ) return 1;
     else if ( m1->pos > m2->pos ) return -1;
     else return 0;
+  case 1: /* POT : pos->ord */
+    if ( m1->pos < m2->pos ) return 1;
+    else if ( m1->pos > m2->pos ) return -1;
+    else return (*cmpdl)(n,m1->dl,m2->dl);
+  case 2:  /* wPOT: weight->pos->ord */
+    if ( m1->dl->td > m2->dl->td ) return 1;
+    else if ( m1->dl->td < m2->dl->td ) return 1;
+    else if ( m1->pos < m2->pos ) return 1;
+    else if ( m1->pos > m2->pos ) return -1;
+    else return (*cmpdl)(n,m1->dl,m2->dl);
+  case 3: /* Schreyer */
+    return compdmm_schreyer(n,m1,m2);
+  default:
+    error("compdmm : invalid dpm_ordtype");
   }
 }
 
 void adddpm(VL vl,DPM p1,DPM p2,DPM *pr)
 {
-  int n;
+  int n,s;
   DMM m1,m2,mr=0,mr0;
   Obj t;
   DL d;
@@ -2645,8 +3080,9 @@ void adddpm(VL vl,DPM p1,DPM p2,DPM *pr)
   else if ( !p2 )
     *pr = p1;
   else {
-    for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; )
-      switch ( compdmm(n,m1,m2) ) {
+    for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {
+      s = compdmm(n,m1,m2);
+      switch ( s ) {
         case 0:
           arf_add(vl,C(m1),C(m2),&t);
           if ( t ) {
@@ -2660,6 +3096,7 @@ void adddpm(VL vl,DPM p1,DPM p2,DPM *pr)
           NEXTDMM(mr0,mr); mr->pos = m2->pos; mr->dl = m2->dl; C(mr) = C(m2);
           m2 = NEXT(m2); break;
       }
+    }
     if ( !mr0 )
       if ( m1 )
         mr0 = m1;
@@ -2709,6 +3146,26 @@ void chsgndpm(DPM p,DPM *pr)
   }
 }
 
+void mulcmp(Obj c,MP m)
+{
+  MP t;
+  Obj c1;
+
+  for ( t = m; t; t = NEXT(t) ) {
+    arf_mul(CO,c,C(t),&c1); C(t) = c1;
+  }
+}
+
+void mulcdmm(Obj c,DMM m)
+{
+  DMM t;
+  Obj c1;
+
+  for ( t = m; t; t = NEXT(t) ) {
+    arf_mul(CO,c,C(t),&c1); C(t) = c1;
+  }
+}
+
 void mulcdpm(VL vl,Obj c,DPM p,DPM *pr)
 {
   DMM m,mr=0,mr0;
@@ -2863,3 +3320,136 @@ int compdpm(VL vl,DPM p1,DPM p2)
   }
 }
 
+void dpm_removecont2(DPM p1,DPM p2,DPM *r1p,DPM *r2p,Z *contp);
+
+// p = ...+c*<<0,...0:pos>>+...
+DPM dpm_eliminate_term(DPM a,DPM p,Obj c,int pos)
+{
+  MP d0,d;
+  DL dl;
+  DMM m;
+  DP f;
+  DPM a1,p1,r,r1,dmy;
+  Z dmyz;
+
+  if ( !a ) return 0;
+  d0 = 0;
+  for ( m = BDY(a); m; m = NEXT(m) )
+    if ( m->pos == pos ) {
+      NEXTMP(d0,d); 
+      arf_chsgn(m->c,&d->c);
+      if ( !dp_current_spec || !dp_current_spec->module_rank )
+        d->dl = m->dl; 
+      else {
+        NEWDL(dl,NV(a));
+        _copydl(NV(a),m->dl,dl);
+        dl->td -= dp_current_spec->module_top_weight[pos-1];
+        d->dl = dl;
+      }
+    }
+  if ( d0 ) {
+    NEXT(d) = 0; MKDP(NV(a),d0,f);
+    mulcdpm(CO,c,a,&a1);
+    mulobjdpm(CO,(Obj)f,p,&p1); 
+    adddpm(CO,a1,p1,&r);
+    dpm_removecont2(0,r,&dmy,&r1,&dmyz);
+    return r1;
+  } else
+    return a;
+}
+
+// <<...:i>> -> <<...:tab[i]>>
+DPM dpm_compress(DPM p,int *tab)
+{
+  DMM m,mr0,mr;
+  DPM t;
+
+  if ( !p ) return 0;
+  else {
+    for ( m = BDY(p), mr0 = 0; m; m = NEXT(m) ) {
+      NEXTDMM(mr0,mr);
+      mr->dl = m->dl; mr->c = m->c; mr->pos = tab[m->pos];
+      if ( mr->pos <= 0 )
+        error("dpm_compress : invalid position");
+    }
+    NEXT(mr) = 0;
+    MKDPM(p->nv,mr0,t); t->sugar = p->sugar;
+    return t;
+  }
+}
+
+// input : s, s = syz(m) output simplified s, m
+void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1,LIST *w1)
+{
+  int lm,ls,i,j,k,pos,nv;
+  DPM *am,*as;
+  DPM p;
+  DMM d;
+  Obj c;
+  Z q;
+  int *tab,*dd,*new_w;
+  NODE t,t1;
+
+  lm = length(BDY(m));
+  am = (DPM *)MALLOC((lm+1)*sizeof(DPM));
+  ls = length(BDY(s));
+  as = (DPM *)MALLOC(ls*sizeof(DPM));
+  for ( i = 1, t = BDY(m); i <= lm; i++, t = NEXT(t) ) am[i] = (DPM)BDY(t);
+  for ( i = 0, t = BDY(s); i < ls; i++, t = NEXT(t) ) as[i] = (DPM)BDY(t);
+
+  for ( i = 0; i < ls; i++ ) {
+    p = as[i];
+    if ( p == 0 ) continue;
+    nv = NV(p);
+    for ( d = BDY(p); d; d = NEXT(d) ) {
+      dd = d->dl->d;
+      for ( k = 0; k < nv; k++ ) if ( dd[k] ) break;
+      if ( k == nv ) break;
+    }
+    if ( d ) {
+      c = d->c; pos = d->pos;
+      for ( j = 0; j < ls; j++ )
+        if ( j != i ) {
+          as[j] = dpm_eliminate_term(as[j],p,c,pos);
+        }
+      // remove m[i]
+      am[pos] = 0;
+      as[i] = 0;
+    }
+  }
+  // compress s
+  // create index table from am[]
+  // (0 0 * 0 * ...) -> (0 0 1 0 2 ... ) which means 2->1, 4->2, ...
+  tab = (int *)MALLOC((lm+1)*sizeof(int));
+  for ( j = 0, i = 1; i <= lm; i++ ) {
+    if ( am[i] ) { j++; tab[i] = j; }
+    else { tab[i] = 0; }
+  }
+  t = 0;
+  for ( i = ls-1; i >= 0; i-- )
+    if ( as[i] ) {
+      p = dpm_compress(as[i],tab);
+      MKNODE(t1,(pointer)p,t); t = t1;
+    }
+  MKLIST(*s1,t);
+
+  if ( dp_current_spec && dp_current_spec->module_rank ) {
+    new_w = (int *)MALLOC(j*sizeof(int));
+    for ( j = 0, i = 1; i <= lm; i++ )
+      if ( tab[i] ) { new_w[j++] = dp_current_spec->module_top_weight[i-1]; }
+    t = 0;
+    for ( i = j-1; i >= 0; i-- ) {
+      STOZ(new_w[i],q);
+      MKNODE(t1,q,t); t = t1;
+    }
+  } else
+    t = 0;
+  MKLIST(*w1,t);
+
+  t = 0;
+  for ( i = lm; i >= 1; i-- )
+    if ( am[i] ) {
+      MKNODE(t1,(pointer)am[i],t); t = t1;
+    }
+  MKLIST(*m1,t);
+}