Changeset f5850b in git

Timestamp:

Jun 1, 2018, 7:50:16 PM (6 years ago)

Author:

Karim Abou Zeid <karim23697@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b4f17ed1d25f93d46dbe29e4b499baecc2fd51bb')

Children:

dc0f002e8452e73b123103f906e73147f38b811c

Parents:

5f13434321a632b9a349403b82d21f853ed48c26

Message:

Adjusted bba to work with the new letterplace multiplication

Files:

• kernel/GBEngine/kInline.h (modified) (1 diff)
• kernel/GBEngine/kspoly.cc (modified) (3 diffs)
• kernel/GBEngine/kstd2.cc (modified) (1 diff)
• kernel/GBEngine/kutil.h (modified) (1 diff)
• kernel/GBEngine/shiftgb.cc (modified) (7 diffs)
• kernel/GBEngine/shiftgb.h (modified) (1 diff)
• libpolys/polys/kbuckets.cc (modified) (1 diff)
• libpolys/polys/kbuckets.h (modified) (1 diff)
• libpolys/polys/shiftop.cc (modified) (4 diffs)

kernel/GBEngine/kInline.h

@@ -594 +594 @@
 }
 
+KINLINE void sLObject::Tail_Minus_mm1_Mult_qq_Mult_mm2(poly m1, poly q, poly m2, int lq, poly spNoether)
+{
+  if (bucket != NULL)
+  {
+    kBucket_Minus_m1_Mult_p_Mult_m2(bucket, m1, q, m2, &lq, NULL); // check if we need noether
+  }
+  else
+  {
+    if (lq<=0) lq= ::pLength(q);
+    poly _p = (t_p != NULL ? t_p : p);
+    assume(_p != NULL);
+
+    int lp=pLength-1;
+    pNext(_p) = p_Minus_mm_Mult_qq( pNext(_p), m1, p_Mult_mm(q, m2, tailRing), lp, lq,
+        spNoether, tailRing );
+    pLength=lp+1;
+    return;
+  }
+}
+
 KINLINE void sLObject::LmDeleteAndIter()
 {

kernel/GBEngine/kspoly.cc

@@ -123 +123 @@
   }
 
+  int holeStart = tailRing->isLPring * p_mFirstVblock(p2, tailRing->isLPring, tailRing);
+  // n1 and n2 is already set to 1
+  poly n1 = p_GetExp_k_n(lm, holeStart, tailRing->N, tailRing);
+  poly n2 = p_GetExp_k_n(lm, 1, holeStart, tailRing);
+
   // take care of coef buisness
   if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
@@ -130 +135 @@
     int ct = ksCheckCoeff(&an, &bn, tailRing->cf);    // Calculate special LC
     p_SetCoeff(lm, bn, tailRing);
+    p_SetCoeff(n1, bn, tailRing);
     if ((ct == 0) || (ct == 2))
       PR->Tail_Mult_nn(an);
@@ -137 +143 @@
   else
   {
+    p_SetCoeff(n1, pGetCoeff(lm), tailRing);
     if (coef != NULL) *coef = n_Init(1, tailRing->cf);
   }
 
-
   // and finally,
-  PR->Tail_Minus_mm_Mult_qq(lm, t2, pLength(t2) /*PW->GetpLength() - 1*/, spNoether);
+  if (tailRing->isLPring) {
+    PR->Tail_Minus_mm1_Mult_qq_Mult_mm2(n1, t2, n2, pLength(t2), spNoether);
+  } else {
+    PR->Tail_Minus_mm_Mult_qq(lm, t2, pLength(t2) /*PW->GetpLength() - 1*/, spNoether);
+  }
   assume(PW->GetpLength() == pLength(PW->p != NULL ? PW->p : PW->t_p));
   PR->LmDeleteAndIter();

kernel/GBEngine/kstd2.cc

@@ -3962 +3962 @@
     if ( ! strat->homog)
     {
-      strat->P.GetP(strat->lmBin); // because shifts are counted with .p structure
+      if (!strat->P.IsNull()) {
+        strat->P.GetP(strat->lmBin); // because shifts are counted with .p structure
+      }
       /* in the nonhomog case we have to shrink the polynomial */
       qq = p_Shrink(strat->P.p, lV, currRing); // direct shrink

kernel/GBEngine/kutil.h

@@ -212 +212 @@
                          int use_bucket, ring r);
   KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether);
+  KINLINE void Tail_Minus_mm1_Mult_qq_Mult_mm2(poly m1, poly qq, poly m2, int lq, poly spNoether);
   KINLINE void Tail_Mult_nn(number n);
   // deletes bucket, makes sure that p and t_p exists

kernel/GBEngine/shiftgb.cc

@@ -78 +78 @@
 
   /* assume sh and uptodeg agree TODO check */
-  assume(sh>=0);
 
   if (sh == 0) return(p); /* the zero shift */
@@ -99 +98 @@
   /* p is a monomial from the ring r */
 
-  if (sh == 0) return(p); /* the zero shift */
-
-  assume(sh>=0);
+  if (sh == 0 || p == NULL) return(p); /* the zero shift */
+
   int L = p_mLastVblock(p,lV,r);
+  assume(L+sh>=1);
   assume(L+sh<=uptodeg);
 
@@ -118 +117 @@
     {
       assume(j + (sh*lV)<=r->N);
+      assume(j + (sh*lV)>=1);
       s[j + (sh*lV)] = e[j]; /* actually 1 */
     }
@@ -175 +175 @@
   /* for a monomial p, returns the number of the last block */
   /* where a nonzero exponent is sitting */
-  if (p_LmIsConstant(p,r))
+  if (p == NULL || p_LmIsConstant(p,r))
   {
     return(0);
@@ -190 +190 @@
 }
 
-int pFirstVblock(poly p, int lV)
+int p_FirstVblock(poly p, int lV, const ring r)
 {
   /* returns the number of maximal block */
   /* appearing among the monomials of p */
   /* the 0th block is the 1st one */
-  poly q = p; //p_Copy(p,currRing); /* need it ? */
-  int ans = 0;
+  if (p == NULL) {
+    return 0;
+  }
+  poly q = p;
+  int ans = p_mFirstVblock(q,lV,r);
   int ansnew = 0;
   while (q!=NULL)
   {
-    ansnew = pmFirstVblock(q,lV);
-    ans    = si_min(ans,ansnew);
+    ansnew = p_mFirstVblock(q,lV,r);
+    if (ansnew > 0) { // don't count constants
+      ans = si_min(ans,ansnew);
+    }
     pIter(q);
   }
@@ -208 +213 @@
 }
 
-int pmFirstVblock(poly p, int lV)
-{
-  if (pIsConstantPoly(p))
-  {
-    return(int(0));
+int p_mFirstVblock(poly p, int lV, const ring r)
+{
+  if (p == NULL || p_LmIsConstant(p,r))
+  {
+    return(0);
   }
   /* for a monomial p, returns the number of the first block */
   /* where a nonzero exponent is sitting */
-  int *e=(int *)omAlloc0((currRing->N+1)*sizeof(int));
-  p_GetExpV(p,e,currRing);
+  int *e=(int *)omAlloc0((r->N+1)*sizeof(int));
+  p_GetExpV(p,e,r);
   int j,b;
   j = 1;
-  while ( (!e[j]) && (j<=currRing->N-1) ) j++;
-  if (j==currRing->N + 1)
-  {
-#ifdef PDEBUG
-    PrintS("pmFirstVblock: unexpected zero exponent vector\n");
-#endif
-    return(j);
-  }
-  b = (int)(j/lV)+1; /* the number of the block, 1<= N <= currRing->N  */
+  while ( (!e[j]) && (j<=r->N-1) ) j++;
+  freeT(e, r->N);
+  assume(j <= r->N);
+  b = (int)(j+lV-1)/lV; /* the number of the block, 1<= b <= r->N  */
   return (b);
 }
@@ -396 +396 @@
   /* r->N is a multiple of lV */
 
+  if (p==NULL) return p;
   int *e = (int *)omAlloc0((r->N+1)*sizeof(int));
   int  b = (int)((r->N +lV-1)/lV); /* the number of blocks */

kernel/GBEngine/shiftgb.h

@@ -32 +32 @@
 #define pmLastVblock(p,lV) p_mLastVblock(p,lV,currRing)
 
-int pFirstVblock(poly p, int lV);
-int pmFirstVblock(poly p, int lV);
+int p_FirstVblock(poly p, int lV, const ring r);
+int p_mFirstVblock(poly p, int lV, const ring r);
+
+//int pLastVblock(poly p, int lV);
+#define pFirstVblock(p,lV) p_FirstVblock(p,lV,currRing)
+//int pmLastVblock(poly p, int lV);
+#define pmFirstVblock(p,lV) p_mFirstVblock(p,lV,currRing)
 
 int isInV(poly p, int lV);

libpolys/polys/kbuckets.cc

@@ -798 +798 @@
 //////////////////////////////////////////////////////////////////////////
 ///
+/// Bpoly == Bpoly - m1*p*m2; where m1 and m2 are monoms
+/// Does not destroy p, m1 and m2
+/// assume (*l <= 0 || pLength(p) == *l)
+void kBucket_Minus_m1_Mult_p_Mult_m2(kBucket_pt bucket, poly m1, poly p, poly m2, int *l, poly spNoether)
+{
+  assume(*l <= 0 || pLength(p) == *l);
+  int i, l1;
+  poly p1 = p;
+  ring r = bucket->bucket_ring;
+
+  if (*l <= 0)
+  {
+    l1 = pLength(p1);
+    *l = l1;
+  }
+  else
+    l1 = *l;
+
+  if (m1 == NULL || m2 == NULL || p == NULL) return;
+
+#ifndef HAVE_PSEUDO_BUCKETS
+  kBucketMergeLm(bucket);
+  kbTest(bucket);
+  i = pLogLength(l1);
+
+#if defined(HAVE_PLURAL)
+  if ((rField_is_Ring(r) && !(rField_is_Domain(r)))
+  ||(rIsPluralRing(r)))
+  {
+    pSetCoeff0(m1, n_InpNeg(pGetCoeff(m1),r->cf));
+    p1=pp_Mult_mm(r->p_Procs->pp_mm_Mult(p, m1, r),m2,r);
+    pSetCoeff0(m1, n_InpNeg(pGetCoeff(m1),r->cf));
+    l1=pLength(p1);
+    i = pLogLength(l1);
+  }
+  else
+#endif
+  {
+    if ((i <= bucket->buckets_used) && (bucket->buckets[i] != NULL))
+    {
+      assume(pLength(bucket->buckets[i])==(unsigned)bucket->buckets_length[i]);
+//#ifdef USE_COEF_BUCKETS
+//     if(bucket->coef[i]!=NULL)
+//     {
+//       poly mult=p_Mult_mm(bucket->coef[i],m,r);
+//       bucket->coef[i]=NULL;
+//       p1 = p_Minus_mm_Mult_qq(bucket->buckets[i], mult, p1,
+//                               bucket->buckets_length[i], l1,
+//                             spNoether, r);
+//     }
+//     else
+//#endif
+      MULTIPLY_BUCKET(bucket,i);
+      p1 = p_Minus_mm_Mult_qq(bucket->buckets[i], m1, p_Mult_mm(p1, m2, r),
+                            bucket->buckets_length[i], l1,
+                            spNoether, r);
+      l1 = bucket->buckets_length[i];
+      bucket->buckets[i] = NULL;
+      bucket->buckets_length[i] = 0;
+      i = pLogLength(l1);
+    }
+    else
+    {
+      pSetCoeff0(m1, n_InpNeg(pGetCoeff(m1),r->cf));
+      if (spNoether != NULL)
+      {
+        l1 = -1;
+        p1 = r->p_Procs->pp_Mult_mm_Noether(r->p_Procs->pp_mm_Mult(p1, m1, r), m2, spNoether, l1, r);
+        i = pLogLength(l1);
+      }
+      else
+      {
+        p1 = r->p_Procs->pp_Mult_mm(r->p_Procs->pp_mm_Mult(p1, m1, r), m2, r);
+      }
+      pSetCoeff0(m1, n_InpNeg(pGetCoeff(m1),r->cf));
+    }
+  }
+
+  while (bucket->buckets[i] != NULL)
+  {
+    //kbTest(bucket);
+    MULTIPLY_BUCKET(bucket,i);
+    p1 = p_Add_q(p1, bucket->buckets[i],
+                 l1, bucket->buckets_length[i], r);
+    bucket->buckets[i] = NULL;
+    bucket->buckets_length[i] = 0;
+    i = pLogLength(l1);
+  }
+
+  bucket->buckets[i] = p1;
+  bucket->buckets_length[i]=l1;
+  if (i >= bucket->buckets_used)
+    bucket->buckets_used = i;
+  else
+    kBucketAdjustBucketsUsed(bucket);
+#else // HAVE_PSEUDO_BUCKETS
+  bucket->p = p_Minus_mm_Mult_qq(bucket->p, m1, p_Mult_mm(p, m2, r),
+                               bucket->l, l1,
+                               spNoether, r);
+#endif
+}
+
+//////////////////////////////////////////////////////////////////////////
+///
 /// Bpoly == Bpoly + m*p; where m is a monom
 /// Does not destroy p and m

libpolys/polys/kbuckets.h

@@ -134 +134 @@
 //////////////////////////////////////////////////////////////////////////
 ///
+/// Bpoly == Bpoly - m1*p*m2; where m1 and m2 are monoms
+/// Does not destroy p, m1 and m2 (TODO: rename into kBucket_Minus_mm1_Mult_pp_Mult_mm2!?)
+/// assume (*l <= 0 || pLength(p) == *l)
+void kBucket_Minus_m1_Mult_p_Mult_m2(kBucket_pt bucket, poly m1, poly p, poly m2, int *l, poly spNother = NULL);
+
+//////////////////////////////////////////////////////////////////////////
+///
 /// Bpoly == Bpoly + m*p; where m is a monom
 /// Does not destroy p and m

libpolys/polys/shiftop.cc

@@ -10 +10 @@
 {
 #ifdef SHIFT_MULT_DEBUG
-  Print("shift_pp_Mult_mm p=%s m=%s", pString(p), pString(m));
-  PrintLn();
+  PrintLn(); PrintS("shift_pp_Mult_mm: "); p_wrp(p, ri, ri); PrintS(" * "); p_wrp(m, ri, ri);
 #endif
 
+  int lV = ri->isLPring;
+  if (p_mFirstVblock(m,lV,ri) < p_mFirstVblock(p,lV,ri)) {
+    // TODO remove this
+    PrintS("WARNING: auto switch to shift_pp_mm_Mult");
+    return shift_pp_mm_Mult(p, m, ri);
+  }
+
   // we just shift m and then call the commutative multiplication
-  int lV = ri->isLPring;
   int uptodeg = ri->N/lV;
-  int shift = p_LastVblock(p, lV, ri);
-  p_mLPshift(m, shift, uptodeg, lV, ri);
+  int pshift = p_LastVblock(p, lV, ri);
+  int mshift = p_mFirstVblock(m, lV, ri) - 1;
+#ifdef SHIFT_MULT_DEBUG
+  if (mshift > 0) {
+    PrintLn();
+    PrintS("WARNING: m is already shifted");
+  }
+#endif
+  poly m2 = p_Copy(m,ri);
+  p_mLPshift(m2, pshift - mshift, uptodeg, lV, ri);
 
   // this is the commutative multiplication procedure
   extern poly pp_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(spolyrec*, spolyrec*, ip_sring*);
-  p = pp_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(p, m, ri);
-  return p_Shrink(p, lV, ri);
+  p = pp_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(p, m2, ri);
+  p = p_Shrink(p, lV, ri);
+#ifdef SHIFT_MULT_DEBUG
+  PrintLn(); PrintS("shift_pp_Mult_mm result: "); p_wrp(p, ri, ri); PrintLn();
+#endif
+  return p;
 }
 
@@ -29 +46 @@
 poly shift_p_Mult_mm(poly p, const poly m, const ring ri)
 {
+  // TODO remove this
+  return shift_pp_Mult_mm(p,m,ri);
 #ifdef SHIFT_MULT_DEBUG
-  Print("shift_p_Mult_mm p=%s m=%s", pString(p), pString(m));
-  PrintLn();
+  PrintLn(); PrintS("shift_p_Mult_mm: "); p_wrp(p, ri, ri); PrintS(" * "); p_wrp(m, ri, ri); PrintLn();
 #endif
 
+  int lV = ri->isLPring;
+  if (p_mFirstVblock(m,lV,ri) < p_mFirstVblock(p,lV,ri)) {
+    // TODO remove this
+    Print("WARNING: auto switch to shift_p_mm_Mult");
+    return shift_p_mm_Mult(p, m, ri);
+  }
+
   // we just shift m and then call the commutative multiplication
+  int uptodeg = ri->N/lV;
+  int pshift = p_LastVblock(p, lV, ri);
+  int mshift = p_mFirstVblock(m, lV, ri) - 1;
+#ifdef SHIFT_MULT_DEBUG
+  if (mshift > 0) {
+    PrintLn(); Print("WARNING: m is already shifted"); PrintLn();
+  }
+#endif
+  poly m2 = p_Copy(m,ri);
+  p_mLPshift(m2, pshift - mshift, uptodeg, lV, ri);
+
+  // this is the commutative multiplication procedure
+  extern poly p_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(spolyrec*, spolyrec*, ip_sring*);
+
+  p = p_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(p, m2, ri);
+  poly q = p_Shrink(p, lV, ri);
+  p_Delete(&p, ri);
+#ifdef SHIFT_MULT_DEBUG
+  PrintLn(); PrintS("shift_p_Mult_mm result: "); p_wrp(q, ri, ri); PrintLn();
+#endif
+  return q;
+}
+
+poly shift_pp_mm_Mult(poly p, const poly m, const ring ri)
+{
+#ifdef SHIFT_MULT_DEBUG
+  PrintLn(); PrintS("shift_pp_mm_Mult: "); p_wrp(m, ri, ri); PrintS(" * "); p_wrp(p, ri, ri); PrintLn();
+#endif
+
   int lV = ri->isLPring;
+  if (p_mFirstVblock(p,lV,ri) < p_mFirstVblock(m,lV,ri)) {
+    // TODO remove this
+    PrintS("WARNING: auto switch to shift_pp_Mult_mm");
+    return shift_pp_Mult_mm(p, m, ri);
+  }
+
+  // we just shift m and then call the commutative multiplication
   int uptodeg = ri->N/lV;
-  int shift = p_LastVblock(p, lV, ri);
-  p_mLPshift(m, shift, uptodeg, lV, ri);
+  int mshift = p_mLastVblock(m, lV, ri);
+  int pshift = p_FirstVblock(p, lV, ri) - 1;
+#ifdef SHIFT_MULT_DEBUG
+  if (pshift > 0) {
+    PrintLn(); PrintS("WARNING: p is already shifted"); PrintLn();
+  }
+#endif
+  p = p_Copy(p,ri);
+  p_LPshift(p, mshift - pshift, uptodeg, lV, ri);
+
+  // this is the commutative multiplication procedure
+  extern poly pp_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(spolyrec*, spolyrec*, ip_sring*);
+  p = pp_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(p, m, ri);
+
+  p = p_Shrink(p, lV, ri);
+#ifdef SHIFT_MULT_DEBUG
+  PrintLn(); PrintS("shift_pp_mm_Mult result: "); p_wrp(p, ri, ri); PrintLn();
+#endif
+  return p;
+}
+
+// destroys p
+poly shift_p_mm_Mult(poly p, const poly m, const ring ri)
+{
+  return shift_pp_mm_Mult(p,m,ri);
+#ifdef SHIFT_MULT_DEBUG
+  PrintLn(); PrintS("shift_p_mm_Mult: "); p_wrp(m, ri, ri); PrintS(" * "); p_wrp(p, ri, ri); PrintLn();
+#endif
+
+  int lV = ri->isLPring;
+  if (p_mFirstVblock(p,lV,ri) < p_mFirstVblock(m,lV,ri)) {
+    // TODO remove this
+    Print("WARNING: auto switch to shift_p_Mult_mm");
+    return shift_p_Mult_mm(p, m, ri);
+  }
+
+  // we just shift m and then call the commutative multiplication
+  int uptodeg = ri->N/lV;
+  int mshift = p_mLastVblock(m, lV, ri);
+  int pshift = p_FirstVblock(p, lV, ri) - 1;
+#ifdef SHIFT_MULT_DEBUG
+  if (pshift > 0) {
+    PrintLn(); PrintS("WARNING: p is already shifted"); PrintLn();
+  }
+#endif
+  p_LPshift(p, mshift - pshift, uptodeg, lV, ri);
 
   // this is the commutative multiplication procedure
@@ -46 +151 @@
   poly q = p_Shrink(p, lV, ri);
   p_Delete(&p, ri);
-  return q;
-}
-
-poly shift_pp_mm_Mult(poly p, const poly m, const ring ri)
-{
 #ifdef SHIFT_MULT_DEBUG
-  Print("shift_pp_mm_Mult p=%s m=%s", pString(p), pString(m));
-  PrintLn();
+  PrintLn(); PrintS("shift_p_mm_Mult resutl: "); p_wrp(q, ri, ri); PrintLn();
 #endif
-
-  // we just shift m and then call the commutative multiplication
-  int lV = ri->isLPring;
-  int uptodeg = ri->N/lV;
-  int shift = p_mLastVblock(m, lV, ri);
-  p_LPshift(p, shift, uptodeg, lV, ri);
-
-  // this is the commutative multiplication procedure
-  extern poly pp_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(spolyrec*, spolyrec*, ip_sring*);
-  p = pp_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(p, m, ri);
-  return p_Shrink(p, lV, ri);
-}
-
-// destroys p
-poly shift_p_mm_Mult(poly p, const poly m, const ring ri)
-{
-#ifdef SHIFT_MULT_DEBUG
-  Print("shift_p_mm_Mult p=%s m=%s", pString(p), pString(m));
-  PrintLn();
-#endif
-
-  // we just shift m and then call the commutative multiplication
-  int lV = ri->isLPring;
-  int uptodeg = ri->N/lV;
-  int shift = p_mLastVblock(m, lV, ri);
-  p_LPshift(p, shift, uptodeg, lV, ri);
-
-  // this is the commutative multiplication procedure
-  extern poly p_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(spolyrec*, spolyrec*, ip_sring*);
-
-  p = p_Mult_mm__FieldGeneral_LengthGeneral_OrdGeneral(p, m, ri);
-  poly q = p_Shrink(p, lV, ri);
-  p_Delete(&p, ri);
   return q;
 }
@@ -95 +161 @@
 
 #ifdef SHIFT_MULT_DEBUG
-  Print("shift_p_Minus_mm_Mult_qq p=%s m=%s q=%s spNoether=%s", pString(p), pString(m), pString(q));
-  PrintLn();
+  PrintLn(); PrintS("shift_p_Minus_mm_Mult_qq: "); p_wrp(p, ri, ri); PrintS(" - "); p_wrp(m, ri, ri); PrintS(" * "); p_wrp(q, ri, ri); PrintLn();
 #endif
 
-  // we just shift m and then call the commutative multiplication
-  int lV = ri->isLPring;
-  int uptodeg = ri->N/lV;
-  int shift = p_mLastVblock(m, lV, ri);
-  p_LPshift(q, shift, uptodeg, lV, ri);
+  Shorter = pLength(p) + pLength(q);
 
-  // this is the commutative multiplication procedure
-  extern poly p_Minus_mm_Mult_qq__FieldGeneral_LengthGeneral_OrdGeneral(spolyrec*, spolyrec*, spolyrec*, int&, spolyrec*, ip_sring*);
+  poly qq = p_Add_q(p, shift_pp_mm_Mult(q, p_Neg(p_Copy(m, ri), ri), ri), ri);
+  /* qq = p_Shrink(qq, lV, ri); // probably not neccessary */
+  /* p_Delete(&p, ri); */ // just for testing disabled
 
-  p = p_Minus_mm_Mult_qq__FieldGeneral_LengthGeneral_OrdGeneral(p, m, q, Shorter, spNoether, ri);
-  poly qq = p_Shrink(p, lV, ri);
-  p_Delete(&p, ri);
+#ifdef SHIFT_MULT_DEBUG
+  PrintLn(); PrintS("shift_p_Minus_mm_Mult_qq result: "); p_wrp(qq, ri, ri); PrintLn();
+#endif
+  Shorter -= pLength(qq);
   return qq;
 }