Changeset dffd154 in git

Timestamp:

Sep 20, 2014, 1:53:38 AM (9 years ago)

Author:

Yue Ren <ren@…>

Branches:

(u'spielwiese', 'f6c3dc58b0df4bd712574325fe76d0626174ad97')

Children:

4664b33f793e7e511d9722557720dd523ec89856

Parents:

b71400abefd0c9c66c0009063f40ddd5b1f1c4c7

git-author:

Yue Ren <ren@mathematik.uni-kl.de>2014-09-20 01:53:38+02:00

git-committer:

Yue Ren <ren@mathematik.uni-kl.de>2015-02-06 13:47:05+01:00

Message:

chg: status update 20.09.

Location:

Singular/dyn_modules/gfanlib

Files:

• groebnerCone.cc (modified) (4 diffs)
• ppinitialReduction.cc (modified) (18 diffs)
• ppinitialReduction.h (modified) (1 diff)
• singularWishlist.h (modified) (1 diff)
• startingCone.cc (modified) (6 diffs)
• std_wrapper.h (modified) (1 diff)
• tropicalStrategy.cc (modified) (9 diffs)
• tropicalStrategy.h (modified) (3 diffs)
• tropicalTraversal.cc (modified) (2 diffs)
• tropicalVariety.cc (modified) (3 diffs)
• witness.cc (modified) (5 diffs)
• witness.h (modified) (1 diff)

Singular/dyn_modules/gfanlib/groebnerCone.cc

@@ -31 +31 @@
 static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
 {
+  return true;
   if (r)
   {
@@ -175 +176 @@
   }
   omFreeSize(expv,(n+1)*sizeof(int));
-  if (currentStrategy->restrictToLowerHalfSpace())
-  {
-    gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
-    lowerHalfSpaceCondition[0] = -1;
-    inequalities.appendRow(lowerHalfSpaceCondition);
-  }
+  // if (currentStrategy->restrictToLowerHalfSpace())
+  // {
+  //   gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
+  //   lowerHalfSpaceCondition[0] = -1;
+  //   inequalities.appendRow(lowerHalfSpaceCondition);
+  // }
 
   polyhedralCone = gfan::ZCone(inequalities,equations);
@@ -238 +239 @@
   }
   omFreeSize(expv,(n+1)*sizeof(int));
-  if (currentStrategy->restrictToLowerHalfSpace())
-  {
-    gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
-    lowerHalfSpaceCondition[0] = -1;
-    inequalities.appendRow(lowerHalfSpaceCondition);
-  }
+  // if (currentStrategy->restrictToLowerHalfSpace())
+  // {
+  //   gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
+  //   lowerHalfSpaceCondition[0] = -1;
+  //   inequalities.appendRow(lowerHalfSpaceCondition);
+  // }
 
   polyhedralCone = gfan::ZCone(inequalities,equations);
@@ -439 +440 @@
    *   to obtain an initial form with respect to interiorPoint+e*facetNormal,
    *   for e>0 sufficiently small */
-  std::pair<ideal,ring> flipped = currentStrategy->getFlip(polynomialIdeal,reducedPolynomialIdeal,polynomialRing,interiorPoint,facetNormal);
+  std::pair<ideal,ring> flipped = currentStrategy->getFlip(reducedPolynomialIdeal,polynomialRing,interiorPoint,facetNormal);
   assume(checkPolynomialInput(flipped.first,flipped.second));
   groebnerCone flippedCone(flipped.first, flipped.second, interiorPoint, facetNormal, *currentStrategy);

Singular/dyn_modules/gfanlib/ppinitialReduction.cc

@@ -29 +29 @@
  * with respect to p-t
  **/
-static bool pReduce(poly &g, const number p, const ring r)
+bool pReduce(poly &g, const number p, const ring r)
 {
   if (g==NULL)
@@ -92 +92 @@
 }
 
+void ptNormalize(poly* gStar, const number p, const ring r)
+{
+  poly g = *gStar;
+  if (g==NULL || n_DivBy(p_GetCoeff(g,r),p,r->cf))
+    return;
+  p_Test(g,r);
+
+  // create p-t
+  poly pt = p_Init(r);
+  p_SetCoeff(pt,n_Copy(p,r->cf),r);
+
+  pNext(pt) = p_Init(r);
+  p_SetExp(pNext(pt),1,1,r);
+  p_Setm(pNext(pt),r);
+  p_SetCoeff(pNext(pt),n_Init(-1,r->cf),r);
+
+  // make g monic with the help of p-t
+  number a,b;
+  number gcd = n_ExtGcd(p_GetCoeff(g,r),p,&a,&b,r->cf);
+  assume(n_IsUnit(gcd,r->cf));
+  // now a*leadcoef(g)+b*p = gcd with gcd being a unit
+  // so a*g+b*(p-t)*leadmonom(g) should have a unit as leading coefficient
+  // but first check whether b is 0,
+  // since p_Mult_nn doesn't allow 0 as number input
+  if (n_IsZero(b,r->cf))
+  {
+    n_Delete(&a,r->cf);
+    n_Delete(&b,r->cf);
+    n_Delete(&gcd,r->cf);
+    p_Delete(&pt,r);
+    return;
+  }
+  poly m = p_Head(g,r);
+  p_SetCoeff(m,n_Init(1,r->cf),r);
+  g = p_Add_q(p_Mult_nn(g,a,r),p_Mult_nn(p_Mult_mm(pt,m,r),b,r),r);
+  n_Delete(&a,r->cf);
+  n_Delete(&b,r->cf);
+  n_Delete(&gcd,r->cf);
+  p_Delete(&m,r);
+
+  p_Test(g,r);
+  return;
+}
+
+void ptNormalize(ideal I, const number p, const ring r)
+{
+  for (int i=0; i<idSize(I); i++)
+    ptNormalize(&(I->m[i]),p,r);
+  return;
+}
+
 #ifndef NDEBUG
 BOOLEAN pppReduce(leftv res, leftv args)
@@ -140 +191 @@
  * assumes that h and g are in pReduced form and homogeneous in x of the same degree
  **/
-bool ppreduceInitially(poly &h, const poly g, const ring r)
-{
+bool ppreduceInitially(poly* hStar, const poly g, const ring r)
+{
+  poly h = *hStar;
   if (h==NULL || g==NULL)
     return false;
@@ -163 +215 @@
     h = p_Add_q(q1,q2,r);
     p_Test(h,r);
+    hStar = &h;
     return true;
   }
@@ -183 +236 @@
       h = (poly) u->CopyD();
       g = (poly) v->CopyD();
-      (void)ppreduceInitially(h,g,currRing);
+      (void)ppreduceInitially(&h,g,currRing);
       p_Delete(&h,currRing);
       p_Delete(&g,currRing);
@@ -190 +243 @@
       h = (poly) u->CopyD();
       g = (poly) v->CopyD();
-      (void)ppreduceInitially(h,g,currRing);
+      (void)ppreduceInitially(&h,g,currRing);
       p_Delete(&g,currRing);
       res->rtyp = POLY_CMD;
@@ -233 +286 @@
   for (int i=0; i<m-1; i++)
     for (int j=i+1; j<m; j++)
-      if (ppreduceInitially(I->m[j], I->m[i], r) && pReduce(I->m[j],p,r)) return true;
+      if (ppreduceInitially(&I->m[j], I->m[i], r) && pReduce(I->m[j],p,r)) return true;
 
   /***
@@ -240 +293 @@
   for (int i=0; i<m-1; i++)
     for (int j=i+1; j<m; j++)
-      if (ppreduceInitially(I->m[i], I->m[j],r) && pReduce(I->m[i],p,r)) return true;
+      if (ppreduceInitially(&I->m[i], I->m[j],r) && pReduce(I->m[i],p,r)) return true;
 
   /***
@@ -309 +362 @@
    **/
   for (int i=0; i<j; i++)
-    if (ppreduceInitially(I->m[j], I->m[i], r) && pReduce(I->m[j],p,r)) return true;
+    if (ppreduceInitially(&I->m[j], I->m[i], r) && pReduce(I->m[j],p,r)) return true;
   for (int k=j+1; k<n; k++)
-    if (ppreduceInitially(I->m[k], I->m[j], r) && pReduce(I->m[k],p,r)) return true;
+    if (ppreduceInitially(&I->m[k], I->m[j], r) && pReduce(I->m[k],p,r)) return true;
 
   /***
@@ -319 +372 @@
   for (int i=0; i<j; i++)
     for (int k=j; k<n; k++)
-      if (ppreduceInitially(I->m[i], I->m[k], r) && pReduce(I->m[i],p,r)) return true;
+      if (ppreduceInitially(&I->m[i], I->m[k], r) && pReduce(I->m[i],p,r)) return true;
   for (int k=j+1; k<n; k++)
-    if (ppreduceInitially(I->m[j], I->m[k], r) && pReduce(I->m[j],p,r)) return true;
+    if (ppreduceInitially(&I->m[j], I->m[k], r) && pReduce(I->m[j],p,r)) return true;
 
   /***
@@ -376 +429 @@
  * assumes that the generators of G are homogeneous in x of lesser degree.
  **/
-bool ppreduceInitially(ideal H, const number p, const ideal G, const ring r)
+bool ppreduceInitially(ideal &H, const number p, const ideal G, const ring r)
 {
   /***
@@ -523 +576 @@
 static std::vector<int> synchronize(const ideal I, const ideal Hi)
 {
-  int k = idSize(Hi);
-  int l = idSize(I);
+  int k = idSize(I);
+  int l = idSize(Hi);
   std::vector<int> synch(k);
   int j;
@@ -532 +585 @@
     {
       if (I->m[i]==Hi->m[j])
+      {
         synch[i] = j;
+        break;
+      }
     }
     if (j==l)
@@ -544 +600 @@
   for (unsigned i=0; i<synch.size(); i++)
     if (synch[i]>=0)
+    {
       I->m[i] = Hi->m[synch[i]];
+      std::cout << i << " -> " << synch[i] << std::endl;
+    }
+}
+
+void z_Write(number p, ring r)
+{
+  poly g = p_One(r);
+  p_SetCoeff(g,p,r);
+  p_Write(g,r);
+  return;
 }
 
@@ -551 +618 @@
  * assumes that the generators of I are homogeneous in x and that p-t is in I.
  */
-bool ppreduceInitially(ideal I, ring r, number p)
+bool ppreduceInitially(ideal I, const ring r, const number p)
 {
   assume(!n_IsUnit(p,r->cf));
@@ -585 +652 @@
    *  and all lower components
    **/
-  std::vector<int> synch = synchronize(I,Hi);
+  // std::vector<int> synch = synchronize(I,Hi);
   if (ppreduceInitially(Hi,p,r)) return true;
-  synchronize(I,Hi,synch);
+  // synchronize(I,Hi,synch);
   id_Test(Hi,r);
   id_Test(I,r);
@@ -625 +692 @@
         break;
       }
+      if (kH==l)
+        break;
       if (p_GetExp(G->m[kG],1,r)>p_GetExp(Hi->m[kH],1,r))
         G->m[i] = G->m[kG++];
@@ -631 +700 @@
     }
     m += l; IDELEMS(GG) = m; GG->m = &G->m[n-m];
-    std::vector<int> synch = synchronize(I,it->second);
+    // std::vector<int> synch = synchronize(I,it->second);
     if (ppreduceInitially(it->second,p,GG,r)) return true;
-    synchronize(I,it->second,synch);
+    // synchronize(I,it->second,synch);
     idShallowDelete(&Hi); Hi = it->second;
   }
   idShallowDelete(&Hi);
 
+  ptNormalize(I,p,r);
   omFreeBin((ADDRESS)GG, sip_sideal_bin); idShallowDelete(&G);
   return false;

Singular/dyn_modules/gfanlib/ppinitialReduction.h

@@ -19 +19 @@
 BOOLEAN ppreduceInitially(leftv res, leftv args);
 
+void z_Write(number p, ring r);
+
 #endif

Singular/dyn_modules/gfanlib/singularWishlist.h

@@ -69 +69 @@
   }
   return;
- }
+}
 
 #endif

Singular/dyn_modules/gfanlib/startingCone.cc

@@ -336 +336 @@
 {
   ring r = currentStrategy.getStartingRing();
-  const ideal I = currentStrategy.getStartingIdeal();
+  ideal I = currentStrategy.getStartingIdeal();
+  currentStrategy.reduce(I,r);
   if (currentStrategy.isConstantCoefficientCase())
   {
@@ -389 +390 @@
     // copy the data, so that it be deleted when passed to the loop
     // s <- r
-    // inI <- I
+    // inJ <- I
     ring s = rCopy(r);
-    int k = idSize(I); ideal inI = idInit(k);
+    int k = idSize(I); ideal inJ = idInit(k);
     nMapFunc identityMap = n_SetMap(r->cf,s->cf);
     for (int i=0; i<k; i++)
-      inI->m[i] = p_PermPoly(I->m[i],NULL,r,s,identityMap,NULL,0);
+      inJ->m[i] = p_PermPoly(I->m[i],NULL,r,s,identityMap,NULL,0);
 
     // and check whether the dimension of its homogeneity space
     // equals the dimension of the tropical variety
-    gfan::ZCone zc = linealitySpaceOfGroebnerFan(inI,s);
+    gfan::ZCone zc = linealitySpaceOfGroebnerFan(inJ,s);
     if (zc.dimension()==currentStrategy.getExpectedDimension())
     { // this shouldn't happen as trivial cases should be caught beforehand
       // this is the case that the tropical variety consists soely out of the lineality space
-      groebnerCone startingCone(I,inI,s,currentStrategy);
-      id_Delete(&inI,s);
+      groebnerCone startingCone(I,inJ,s,currentStrategy);
+      id_Delete(&inJ,s);
       rDelete(s);
       return startingCone;
@@ -410 +411 @@
     // compute a point in the tropical variety outside the lineality space
     // compute the initial ideal with respect to the weight
-    std::pair<gfan::ZVector,groebnerCone> startingData = tropicalStartingDataViaGroebnerFan(inI,s,currentStrategy);
+    std::pair<gfan::ZVector,groebnerCone> startingData = tropicalStartingDataViaGroebnerFan(inJ,s,currentStrategy);
     gfan::ZVector startingPoint = startingData.first;
     groebnerCone ambientMaximalCone = groebnerCone(startingData.second);
-    id_Delete(&inI,s); rDelete(s);
-    inI = ambientMaximalCone.getPolynomialIdeal();
+    id_Delete(&inJ,s); rDelete(s);
+    inJ = ambientMaximalCone.getPolynomialIdeal();
     s = ambientMaximalCone.getPolynomialRing();
-    inI = sloppyInitial(inI,s,startingPoint);
-    zc = linealitySpaceOfGroebnerFan(inI,s);
+    inJ = sloppyInitial(inJ,s,startingPoint);
+    ideal inI = initial(I,r,startingPoint);
+    zc = linealitySpaceOfGroebnerFan(inJ,s);
 
     // and check whether the dimension of its homogeneity space
@@ -424 +426 @@
     { // this case shouldn't happen as trivial cases should be caught beforehand
       // this is the case that the tropical variety has a one-codimensional lineality space
-      ideal J = lift(I,r,inI,s);
-      groebnerCone startingCone(J,inI,s,currentStrategy);
-      id_Delete(&inI,s);
+      ideal J = lift(I,r,inJ,s);
+      groebnerCone startingCone(J,inJ,s,currentStrategy);
+      id_Delete(&inJ,s);
       id_Delete(&J,s);
       return startingCone;
     }
 
-    // from this point on, inI contains the uniformizing parameter,
+    // from this point on, inJ contains the uniformizing parameter,
     // hence it contains a monomial if and only if its residue over the residue field does.
     // so we will switch to the residue field
@@ -439 +441 @@
     rComplete(rShortcut);
     rTest(rShortcut);
-    k = idSize(inI);
-    ideal inIShortcut = idInit(k);
+    k = idSize(inJ);
+    ideal inJShortcut = idInit(k);
     nMapFunc takingResidues = n_SetMap(s->cf,rShortcut->cf);
     for (int i=0; i<k; i++)
-      inIShortcut->m[i] = p_PermPoly(inI->m[i],NULL,s,rShortcut,takingResidues,NULL,0);
-    idSkipZeroes(inIShortcut);
-    id_Delete(&inI,s);
-
-    // we are interested in a maximal cone of the tropical variety of inIShortcut
+      inJShortcut->m[i] = p_PermPoly(inJ->m[i],NULL,s,rShortcut,takingResidues,NULL,0);
+    idSkipZeroes(inJShortcut);
+    id_Delete(&inJ,s);
+
+    // we are interested in a maximal cone of the tropical variety of inJShortcut
     // this basically equivalent to the case without valuation (or constant coefficient case)
     // except that our ideal is still only homogeneous in the later variables,
     // hence we set the optional parameter completelyHomogeneous as 'false'
-    tropicalStrategy shortcutStrategy(inIShortcut,rShortcut,false);
+    tropicalStrategy shortcutStrategy(inJShortcut,rShortcut,false);
     groebnerCone startingConeShortcut = tropicalStartingCone(shortcutStrategy);
-    id_Delete(&inIShortcut,rShortcut); rDelete(rShortcut);
-
-    // now we need to obtain the initial of the residue of inI
+    id_Delete(&inJShortcut,rShortcut); rDelete(rShortcut);
+
+    // now we need to obtain the initial of the residue of inJ
     // with respect to a weight in the tropical cone,
-    // and obtain the initial of inI with respect to the same weight
+    // and obtain the initial of inJ with respect to the same weight
     ring sShortcut = startingConeShortcut.getPolynomialRing();
-    inIShortcut = startingConeShortcut.getPolynomialIdeal();
+    inJShortcut = startingConeShortcut.getPolynomialIdeal();
     gfan::ZCone zd = startingConeShortcut.getPolyhedralCone();
     gfan::ZVector interiorPoint = startingConeShortcut.getInteriorPoint();
-    inIShortcut = sloppyInitial(inIShortcut,sShortcut,interiorPoint);
+    inJShortcut = sloppyInitial(inJShortcut,sShortcut,interiorPoint);
+    inI = initial(inI,r,interiorPoint);
 
     s = rCopy0(sShortcut); // s will be a ring over the valuation ring
@@ -470 +473 @@
     rTest(s);
 
-    k = idSize(inIShortcut); // inI will be overwritten with initial of inI
-    inI = idInit(k+1);
-    inI->m[0] = p_One(s);    // with respect to that weight
+    k = idSize(inJShortcut); // inJ will be overwritten with initial of inJ
+    inJ = idInit(k+1);
+    inJ->m[0] = p_One(s);    // with respect to that weight
     identityMap = n_SetMap(r->cf,s->cf); // first element will obviously be p
-    p_SetCoeff(inI->m[0],identityMap(currentStrategy.getUniformizingParameter(),r->cf,s->cf),s);
+    p_SetCoeff(inJ->m[0],identityMap(currentStrategy.getUniformizingParameter(),r->cf,s->cf),s);
     nMapFunc findingRepresentatives = n_SetMap(sShortcut->cf,s->cf);
     for (int i=0; i<k; i++)              // and then come the rest
-      inI->m[i+1] = p_PermPoly(inIShortcut->m[i],NULL,sShortcut,s,findingRepresentatives,NULL,0);
-
-    ideal J = lift(I,r,inI,s);
+      inJ->m[i+1] = p_PermPoly(inJShortcut->m[i],NULL,sShortcut,s,findingRepresentatives,NULL,0);
+
+    ideal J = currentStrategy.computeLift(inJ,s,inI,I,r);
     // currentStrategy.reduce(J,s);
-    groebnerCone startingCone(J,inI,s,currentStrategy);
-    id_Delete(&inI,s);
+    groebnerCone startingCone(J,inJ,s,currentStrategy);
+    id_Delete(&inJ,s);
     id_Delete(&J,s);
     rDelete(s);
+    id_Delete(&inI,r);
 
     assume(checkContainmentInTropicalVariety(startingCone));

Singular/dyn_modules/gfanlib/std_wrapper.h

@@ -2 +2 @@
 #define CALLGFANLIB_STD_WRAPPER_H
 
-#include <kernel/GBEngine/kstd1.h>
-#include <kernel/polys.h>
+#include <libpolys/polys/simpleideals.h>
+#include <kernel/structs.h>
 
 ideal gfanlib_kStd_wrapper(ideal I, ring r, tHomog h=testHomog);

Singular/dyn_modules/gfanlib/tropicalStrategy.cc

@@ -9 +9 @@
 #include <kernel/ideals.h>
 #include <kernel/GBEngine/stairc.h>
+#include <kernel/GBEngine/kstd1.h>
 #include <Singular/ipshell.h> // for isPrime(int i)
 
@@ -48 +49 @@
  * Initializes all relevant structures and information for the trivial valuation case,
  * i.e. computing a tropical variety without any valuation.
- *g
  */
 tropicalStrategy::tropicalStrategy(const ideal I, const ring r,
@@ -67 +67 @@
 {
   assume(rField_is_Q(r) || rField_is_Zp(r));
-  startingIdeal = gfanlib_kStd_wrapper(startingIdeal,startingRing);
   if (!completelyHomogeneous)
   {
@@ -127 +126 @@
   }
   return rCopy(r);
+}
+
+static ideal constructStartingIdeal(ideal originalIdeal, ring originalRing, number uniformizingParameter, ring startingRing)
+{
+  // construct p-t
+  poly g = p_One(startingRing);
+  p_SetCoeff(g,uniformizingParameter,startingRing);
+  pNext(g) = p_One(startingRing);
+  p_SetExp(pNext(g),1,1,startingRing);
+  p_SetCoeff(pNext(g),n_Init(-1,startingRing->cf),startingRing);
+  p_Setm(pNext(g),startingRing);
+  ideal pt = idInit(1);
+  pt->m[0] = g;
+
+  // map originalIdeal from originalRing into startingRing
+  int k = idSize(originalIdeal);
+  ideal J = idInit(k+1);
+  nMapFunc nMap = n_SetMap(originalRing->cf,startingRing->cf);
+  int n = rVar(originalRing);
+  int* shiftByOne = (int*) omAlloc((n+1)*sizeof(int));
+  for (int i=1; i<=n; i++)
+    shiftByOne[i]=i+1;
+  for (int i=0; i<k; i++)
+    J->m[i] = p_PermPoly(originalIdeal->m[i],shiftByOne,originalRing,startingRing,nMap,NULL,0);
+  omFreeSize(shiftByOne,(n+1)*sizeof(int));
+
+  ring origin = currRing;
+  rChangeCurrRing(startingRing);
+  ideal startingIdeal = kNF(pt,startingRing->qideal,J);
+  rChangeCurrRing(origin);
+  assume(startingIdeal->m[k]==NULL);
+  startingIdeal->m[k] = pt->m[0];
+  startingIdeal = gfanlib_kStd_wrapper(startingIdeal,startingRing);
+
+  id_Delete(&J,startingRing);
+  pt->m[0] = NULL;
+  id_Delete(&pt,startingRing);
+  return startingIdeal;
 }
 
@@ -149 +186 @@
   /* assume that the ground field of the originalRing is Q */
   assume(rField_is_Q(s));
-  originalRing = rCopy(s);
 
   /* replace Q with Z for the startingRing
@@ -160 +196 @@
 
   /* map the input ideal into the new polynomial ring */
-  int k = idSize(J);
-  startingIdeal = idInit(k+1);
-  poly g = p_One(startingRing);
-  p_SetCoeff(g,uniformizingParameter,startingRing);
-  pNext(g) = p_One(startingRing);
-  p_SetExp(pNext(g),1,1,startingRing);
-  p_SetCoeff(pNext(g),n_Init(-1,startingRing->cf),startingRing);
-  p_Setm(pNext(g),startingRing);
-  startingIdeal->m[0] = g;
-  int n = rVar(originalRing);
-  int* shiftByOne = (int*) omAlloc((n+1)*sizeof(int));
-  for (int i=1; i<=n; i++)
-    shiftByOne[i]=i+1;
-  for (int i=0; i<k; i++)
-    startingIdeal->m[i+1] = p_PermPoly(J->m[i],shiftByOne,originalRing,startingRing,nMap,NULL,0);
-  omFreeSize(shiftByOne,(n+1)*sizeof(int));
-  startingIdeal = gfanlib_kStd_wrapper(startingIdeal,startingRing);
+  startingIdeal = constructStartingIdeal(J,s,uniformizingParameter,startingRing);
 
   linealitySpace = homogeneitySpace(startingIdeal,startingRing);
@@ -529 +549 @@
 }
 
+ideal tropicalStrategy::computeLift(const ideal inJs, const ring s, const ideal inIr, const ideal Ir, const ring r) const
+{
+  int k = idSize(inJs);
+  ideal inJr = idInit(k);
+  nMapFunc identitysr = n_SetMap(s->cf,r->cf);
+  for (int i=0; i<k; i++)
+    inJr->m[i] = p_PermPoly(inJs->m[i],NULL,s,r,identitysr,NULL,0);
+
+  ideal Jr = getWitness(inJr,inIr,Ir,r);
+  nMapFunc identityrs = n_SetMap(r->cf,s->cf);
+  ideal Js = idInit(k);
+  for (int i=0; i<k; i++)
+    Js->m[i] = p_PermPoly(Jr->m[i],NULL,r,s,identityrs,NULL,0);
+  return Js;
+}
+
 static void deleteOrdering(ring r)
 {
@@ -610 +646 @@
 }
 
-
-std::pair<ideal,ring> tropicalStrategy::getFlip(const ideal I, const ideal redI, const ring r,
+std::pair<ideal,ring> tropicalStrategy::getFlip(const ideal Ir, const ring r,
                                                 const gfan::ZVector interiorPoint,
                                                 const gfan::ZVector facetNormal) const
 {
   assume(isValuationTrivial() || interiorPoint[0].sign()<0);
-  assume(checkForUniformizingBinomial(I,r));
+  assume(checkForUniformizingBinomial(Ir,r));
 
   // get a generating system of the initial ideal
   // and compute a standard basis with respect to adjacent ordering
-  ideal inIr = initial(redI,r,interiorPoint);
+  ideal inIr = initial(Ir,r,interiorPoint);
   ring sAdjusted = copyAndChangeOrderingWP(r,interiorPoint,facetNormal);
   nMapFunc identity = n_SetMap(r->cf,sAdjusted->cf);
-  int k = idSize(I); ideal inIsAdjusted = idInit(k);
+  int k = idSize(Ir); ideal inIsAdjusted = idInit(k);
   for (int i=0; i<k; i++)
     inIsAdjusted->m[i] = p_PermPoly(inIr->m[i],NULL,r,sAdjusted,identity,NULL,0);
@@ -636 +671 @@
     inJr->m[i] = p_PermPoly(inJsAdjusted->m[i],NULL,sAdjusted,r,identity,NULL,0);
 
-  ideal Jr = getWitness(inJr,inIr,redI,r);
+  ideal Jr = getWitness(inJr,inIr,Ir,r);
   ring s = copyAndChangeOrderingLS(r,interiorPoint,facetNormal);
   identity = n_SetMap(r->cf,s->cf);

Singular/dyn_modules/gfanlib/tropicalStrategy.h

@@ -40 +40 @@
   /**
    * the expected Dimension of the polyhedral output,
-   * i.e. the dimension of the ideal if trivial valuation
-   * or the dimension of the ideal plus one if non-trivial valuation
+   * i.e. the dimension of the ideal if valuation trivial
+   * or the dimension of the ideal plus one if valuation non-trivial
    * (as the output is supposed to be intersected with a hyperplane)
    */
@@ -302 +302 @@
   ideal getWitness(const ideal inJ, const ideal inI, const ideal I, const ring r) const;
 
+  ideal computeLift(const ideal inJs, const ring s, const ideal inIr, const ideal Ir, const ring r) const;
+
   /**
    * given generators of the initial ideal, computes its standard basis
@@ -311 +313 @@
    * computes the groebner cone adjacent to it
    */
-  std::pair<ideal,ring> getFlip(const ideal I, const ideal redI, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal) const;
+  std::pair<ideal,ring> getFlip(const ideal Ir, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal) const;
 };
 

Singular/dyn_modules/gfanlib/tropicalTraversal.cc

@@ -8 +8 @@
   while(!workingList.empty())
   {
-    // std::cout << "starting traversal" << std::endl;
+    std::cout << "starting traversal" << std::endl;
     const groebnerCone sigma=*(workingList.begin());
     const groebnerCones neighbours = sigma.tropicalNeighbours();
@@ -18 +18 @@
     tropicalVariety.insert(sigma);
     workingList.erase(sigma);
-    // std::cout << "tropicalVariety.size():" << tropicalVariety.size() << std::endl;
-    // std::cout << "workingList.size():" << workingList.size() << std::endl;
+    std::cout << "tropicalVariety.size():" << tropicalVariety.size() << std::endl;
+    std::cout << "workingList.size():" << workingList.size() << std::endl;
   }
   return tropicalVariety;

Singular/dyn_modules/gfanlib/tropicalVariety.cc

@@ -1 +1 @@
 #include <callgfanlib_conversion.h>
+#include <std_wrapper.h>
 #include <bbfan.h>
 #include <groebnerCone.h>
@@ -36 +37 @@
     if (v==NULL)
     {
+      setOptionRedSB();
+      if (!hasFlag(u,FLAG_STD))
+        I = gfanlib_kStd_wrapper(I,currRing);
       tropicalStrategy currentStrategy(I,currRing);
-      setOptionRedSB();
       gfan::ZFan* tropI = tropicalVariety(currentStrategy);
-      undoSetOptionRedSB();
       res->rtyp = fanID;
       res->data = (char*) tropI;
+      undoSetOptionRedSB();
       return FALSE;
     }
@@ -47 +50 @@
     {
       number p = (number) v->CopyD();
+      if (!hasFlag(u,FLAG_STD))
+        I = gfanlib_kStd_wrapper(I,currRing);
       tropicalStrategy currentStrategy(I,p,currRing);
       gfan::ZFan* tropI = tropicalVariety(currentStrategy);

Singular/dyn_modules/gfanlib/witness.cc

@@ -7 +7 @@
 #include <utility>
 
-/***
- * Given f and G={g1,...,gk}, computes Q=(q1,...,qk) such that
- * f = q1*g1+...+qk*gk
- * is a determinate division with remainder with respect to the
- * ordering active in r.
- * Returns an error if this is not possible.
- **/
 matrix divisionDiscardingRemainder(const poly f, const ideal G, const ring r)
 {
@@ -26 +19 @@
 }
 
-/**
- * Given F[0],...,F[l] and G[0],...,G[k],
- * computes Q[i,j] for i=0,..,k and j=0,...,l such that
- * F[j] = Q[0,j]*G[0]+...+Q[k,j]*G[k].
- */
 matrix divisionDiscardingRemainder(const ideal F, const ideal G, const ring r)
 {
@@ -44 +32 @@
 }
 
-#ifndef NDEBUG
-BOOLEAN dwr0(leftv res, leftv args)
-{
-  leftv u = args;
-  leftv v = u->next;
-  poly f = (poly) u->CopyD();
-  ideal G = (ideal) v->CopyD();
-  omUpdateInfo();
-  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
-  matrix Q = divisionDiscardingRemainder(f,G,currRing);
-  p_Delete(&f,currRing);
-  id_Delete(&G,currRing);
-  res->rtyp = MATRIX_CMD;
-  res->data = (char*) Q;
-  return FALSE;
-}
-#endif
-
-/***
- * Let w be the uppermost weight vector in the matrix defining the ordering on r.
- * Let I be a Groebner basis of an ideal in r, inI its initial form with respect w.
- * Given an w-homogeneous element m of inI, computes a witness g of m in I,
- * i.e. g in I such that in_w(g)=m.
- **/
 poly witness(const poly m, const ideal I, const ideal inI, const ring r)
 {
@@ -86 +50 @@
 }
 
-#ifndef NDEBUG
-BOOLEAN witness0(leftv res, leftv args)
-{
-  leftv u = args;
-  leftv v = u->next;
-  leftv w = v->next;
-  poly m = (poly) u->CopyD();
-  ideal G = (ideal) v->CopyD();
-  ideal inG = (ideal) w->CopyD();
-  omUpdateInfo();
-  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
-  poly f = witness(m,G,inG,currRing);
-  p_Delete(&m,currRing);
-  id_Delete(&G,currRing);
-  id_Delete(&inG,currRing);
-  res->rtyp = POLY_CMD;
-  res->data = (char*) f;
-  return FALSE;
-}
-#endif
-
-/***
- * Let w be the uppermost weight vector in the matrix defining the ordering on r.
- * Let I be a Groebner basis of an ideal in r, inI its initial form with respect w.
- * Given an w-homogeneous element m of inI, computes a witness g of m in I,
- * i.e. g in I such that in_w(g)=m.
- **/
 ideal witness(const ideal inI, const ideal J, const ring r)
 {
@@ -132 +69 @@
   return I;
 }
+
+#ifndef NDEBUG
+BOOLEAN dwrDebug(leftv res, leftv args)
+{
+  leftv u = args;
+  leftv v = u->next;
+  ideal F = (ideal) u->CopyD();
+  ideal G = (ideal) v->CopyD();
+  omUpdateInfo();
+  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
+  matrix Q = divisionDiscardingRemainder(F,G,currRing);
+  id_Delete(&F,currRing);
+  id_Delete(&G,currRing);
+  res->rtyp = MATRIX_CMD;
+  res->data = (char*) Q;
+  return FALSE;
+}
+
+BOOLEAN witnessDebug(leftv res, leftv args)
+{
+  leftv u = args;
+  leftv v = u->next;
+  ideal inI = (ideal) u->CopyD();
+  ideal J = (ideal) v->CopyD();
+  omUpdateInfo();
+  Print("usedBytesBefore=%ld\n",om_Info.UsedBytes);
+  ideal I = witness(inI,J,currRing);
+  id_Delete(&inI,currRing);
+  id_Delete(&J,currRing);
+  res->rtyp = IDEAL_CMD;
+  res->data = (char*) I;
+  return FALSE;
+}
+#endif

Singular/dyn_modules/gfanlib/witness.h

@@ -5 +5 @@
 #include <libpolys/polys/simpleideals.h>
 
+/**
+ * Computes a division discarding remainder of f with respect to G.
+ * Given f a polynomial and G={g1,...,gk} a set of polynomials in r,
+ * returns a matrix Q=(q1,...,qk) over r such that
+ *   f = q1*g1+...+qk*gk+s
+ * is a determinate division with remainder s.
+ */
 matrix divisionDiscardingRemainder(const poly f, const ideal G, const ring r);
+
+/**
+ * Computes a division discarding remainder of F with respect to G.
+ * Given F={f1,...,fl} and G={g1,...,gk} two sets of polynomials in r,
+ * returns a matrix Q=(qij) i=1,..,k j=1,...,l over r such that
+ *   fj = q1j*g1+...+qkj*gk+sj
+ * is a determinate division with remainder sj for all j=1,...,l.
+ */
 matrix divisionDiscardingRemainder(const ideal F, const ideal G, const ring r);
+
+/**
+ * Let w be the uppermost weight vector in the matrix defining the ordering on r.
+ * Let I be a Groebner basis of an ideal in r, inI its initial form with respect w.
+ * Given an w-homogeneous element m of inI, computes a witness g of m in I,
+ * i.e. g in I such that in_w(g)=m.
+ */
 poly witness(const poly m, const ideal I, const ideal inI, const ring r);
+
+/**
+ * Computes witnesses in J for inI
+ * Given inI={h1,...,hl} and J={g1,...,gk} two sets of polynomials in r,
+ * returns a set I={f1,...,fl} of <g1,...,gk> such that
+ *   in_w(fj)=hj for all j=1,...,l,
+ * where w denotes the uppoermost weight vector in the matrix defining the ordering on r.
+ * Assumes that hj is an element of <in_w(g1),...,in_w(gk)>
+ */
 ideal witness(const ideal inI, const ideal J, const ring r);
 
 #ifndef NDEBUG
 #include <Singular/ipid.h>
-
-BOOLEAN dwr0(leftv res, leftv args);
-BOOLEAN witness0(leftv res, leftv args);
+BOOLEAN dwrDebug(leftv res, leftv args);
+BOOLEAN witnessDebug(leftv res, leftv args);
 #endif