Changeset eacb781 in git

Timestamp:

Aug 23, 2014, 4:25:47 PM (9 years ago)

Author:

Yue Ren <ren@…>

Branches:

(u'spielwiese', '91e5db82acc17434e4062bcfa44e6efa7d41fd30')

Children:

9c03260ac0404405e4994f73b30ef46f079535d8

Parents:

78abc705dd6af8b10c453361ab125294a2432189

git-author:

Yue Ren <ren@mathematik.uni-kl.de>2014-08-23 16:25:47+02:00

git-committer:

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

Message:

chg: status update 23.08.

Location:

Singular/dyn_modules/gfanlib

Files:

• adjustWeights.cc (modified) (5 diffs)
• containsMonomial.cc (modified) (3 diffs)
• flip.cc (modified) (3 diffs)
• flip.h (modified) (1 diff)
• groebnerCone.cc (modified) (12 diffs)
• groebnerCone.h (modified) (2 diffs)
• initial.cc (modified) (1 diff)
• neighbours.cc (modified) (2 diffs)
• ppinitialReduction.cc (modified) (8 diffs)
• startingCone.cc (modified) (9 diffs)
• startingCone.h (modified) (1 diff)
• tropical.cc (modified) (1 diff)
• tropicalCurves.cc (modified) (3 diffs)
• tropicalStrategy.cc (modified) (10 diffs)
• tropicalStrategy.h (modified) (9 diffs)
• tropicalVariety.cc (modified) (2 diffs)
• tropicalVarietyOfIdeals.cc (modified) (1 diff)
• witness.cc (modified) (2 diffs)

Singular/dyn_modules/gfanlib/adjustWeights.cc

@@ -4 +4 @@
 static bool checkForNonPositiveEntries(const gfan::ZVector w)
 {
-  for (unsigned i=1; i<w.size(); i++)
+  for (unsigned i=0; i<w.size(); i++)
   {
     if (w[i].sign()<=0)
@@ -15 +15 @@
   return true;
 }
+
+static bool checkForNonPositiveLaterEntries(const gfan::ZVector w)
+{
+  if (w[0].sign()<0)
+  {
+    std::cout << "ERROR: negative weight in weight vector first entry" << std::endl
+              << "weight: " << w << std::endl;
+    return false;
+  }
+  for (unsigned i=1; i<w.size(); i++)
+  {
+    if (w[i].sign()<=0)
+    {
+      std::cout << "ERROR: non-positive weight in weight vector later entries" << std::endl
+                << "weight: " << w << std::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
 
 /***
@@ -50 +71 @@
   for (unsigned i=1; i<w.size(); i++)
     v[i]=-w[i]+max+1;
-  assume(checkForNonPositiveEntries(v));
+  assume(checkForNonPositiveLaterEntries(v));
   return v;
 }
@@ -87 +108 @@
 gfan::ZVector valued_adjustWeightUnderHomogeneity(const gfan::ZVector e, const gfan::ZVector w)
 {
-  assume(checkForNonPositiveEntries(w));
+  assume(checkForNonPositiveLaterEntries(w));
   /* find k such that e+k*w is strictly positive,
    * i.e. k such that e[i]+k*w[i] is strictly positive
    * for all i=0,...,n */
   gfan::Integer k((long)0);
-  if (e[0].sign()<=0)
+  if (e[0].sign()<=0 && w[0].sign()>0)
     k = gfan::Integer((long)1)-(e[0]/w[0]);
   for (unsigned i=1; i<e.size(); i++)
@@ -105 +126 @@
   /* compute e+k*w, check it for correctness and return it */
   gfan::ZVector v = e+k*w;
-  assume(checkForNonPositiveEntries(v));
+  assume(checkForNonPositiveLaterEntries(v));
   return v;
 }

Singular/dyn_modules/gfanlib/containsMonomial.cc

@@ -62 +62 @@
   }
   rComplete(s,1);
+  rTest(s);
   return s;
 }
@@ -93 +94 @@
 
   rComplete(s,1);
+  rTest(s);
   return s;
 }
@@ -136 +138 @@
   r->cf = nInitChar(n_Zp,(void*)(long)n_Int(p_GetCoeff(I->m[0],currRing),currRing->cf));
   rComplete(r);
+  rTest(r);
 
   ideal J = id_Copy(I, currRing); poly cache; number temp;

Singular/dyn_modules/gfanlib/flip.cc

@@ -38 +38 @@
  *  (2) Is is a Groebner basis of the same ideal with respect to the ordering on s
  **/
-std::pair<ideal,ring> flip(const ideal I, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal, const tropicalStrategy& currentStrategy)
+std::pair<ideal,ring> flip0(const ideal I, const ring r,
+                            const gfan::ZVector interiorPoint,
+                            const gfan::ZVector facetNormal,
+                            const gfan::ZVector adjustedInteriorPoint,
+                            const gfan::ZVector adjustedFacetNormal)
 {
-  /* read out appropiate functions for adjusting weights and adjust themm */
-  gfan::ZVector adjustedInteriorPoint = currentStrategy.adjustWeightForHomogeneity(interiorPoint);
-  gfan::ZVector adjustedFacetNormal = currentStrategy.adjustWeightUnderHomogeneity(facetNormal,adjustedInteriorPoint);
-
   /* create a ring with weighted ordering  */
   bool ok;
@@ -62 +62 @@
   sAdjusted->wvhdl[1] = ZVectorToIntStar(adjustedFacetNormal,ok);
   sAdjusted->order[2] = ringorder_C;
-  rComplete(sAdjusted,1);
+  rComplete(sAdjusted);
+  rTest(sAdjusted);
   nMapFunc identity = n_SetMap(r->cf,sAdjusted->cf);
 
@@ -100 +101 @@
   s->block1[2] = n;
   s->order[3] = ringorder_C;
-  rComplete(s,1);
+  rComplete(s);
+  rTest(s);
   identity = n_SetMap(sAdjusted->cf,s->cf);
   k = idSize(IsAdjustedGB); ideal IsGB = idInit(k);

Singular/dyn_modules/gfanlib/flip.h

@@ -1 @@
-#ifndef FLIP_H
-#define FLIP_H
+#ifndef GFANLIB_FLIP_H
+#define GFANLIB_FLIP_H
 
 #include <utility>
 #include <libpolys/polys/simpleideals.h>
+#include <gfanlib/gfanlib_vector.h>
 
-#include <gfanlib/gfanlib_vector.h>
-#include <tropicalStrategy.h>
-
-std::pair<ideal,ring> flip(const ideal I, const ring r, const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal, const tropicalStrategy& currentCase);
+std::pair<ideal,ring> flip0(const ideal I, const ring r,
+                            const gfan::ZVector interiorPoint,
+                            const gfan::ZVector facetNormal,
+                            const gfan::ZVector adjustedInteriorPoint,
+                            const gfan::ZVector adjustedFacetNormal);
 
 #endif

Singular/dyn_modules/gfanlib/groebnerCone.cc

@@ -72 +72 @@
   if (I) polynomialIdeal = id_Copy(I,r);
   if (r) polynomialRing = rCopy(r);
+  currentCase.reduce(I,r);
 
   int n = rVar(polynomialRing);
@@ -82 +83 @@
   for (int i=0; i<idSize(polynomialIdeal); i++)
   {
-    g = polynomialIdeal->m[i];
-    pGetExpV(g,leadexpv);
-    leadexpw = intStar2ZVector(n, leadexpv);
-    pIter(g);
-    while (g)
-    {
-      pGetExpV(g,tailexpv);
-      tailexpw = intStar2ZVector(n, tailexpv);
-      inequalities.appendRow(leadexpw-tailexpw);
+    g = I->m[i];
+    if (g)
+    {
+      p_GetExpV(g,leadexpv,r);
+      leadexpw = intStar2ZVector(n, leadexpv);
       pIter(g);
+      while (g)
+      {
+        p_GetExpV(g,tailexpv,r);
+        tailexpw = intStar2ZVector(n, tailexpv);
+        inequalities.appendRow(leadexpw-tailexpw);
+        pIter(g);
+      }
     }
   }
   omFreeSize(leadexpv,(n+1)*sizeof(int));
   omFreeSize(tailexpv,(n+1)*sizeof(int));
+  if (currentStrategy->restrictToLowerHalfSpace())
+  {
+    gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
+    lowerHalfSpaceCondition[0] = -1;
+    inequalities.appendRow(lowerHalfSpaceCondition);
+  }
+
   polyhedralCone = gfan::ZCone(inequalities,gfan::ZMatrix(0, inequalities.getWidth()));
+  polyhedralCone.canonicalize();
   interiorPoint = polyhedralCone.getRelativeInteriorPoint();
   assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
@@ -116 +128 @@
   if (I) polynomialIdeal = id_Copy(I,r);
   if (r) polynomialRing = rCopy(r);
+  currentCase.reduce(I,r);
 
   int n = rVar(r);
@@ -124 +137 @@
   {
     poly g = polynomialIdeal->m[i];
-    p_GetExpV(g,expv,polynomialRing);
-    gfan::ZVector leadexpv = intStar2ZVector(n,expv);
-    long d = wDeg(g,polynomialRing,w);
-    for (pIter(g); g; pIter(g))
+    if (g)
     {
       p_GetExpV(g,expv,polynomialRing);
-      gfan::ZVector tailexpv = intStar2ZVector(n,expv);
-      if (wDeg(g,polynomialRing,w)==d)
-        equations.appendRow(leadexpv-tailexpv);
-      else
+      gfan::ZVector leadexpv = intStar2ZVector(n,expv);
+      long d = wDeg(g,polynomialRing,w);
+      for (pIter(g); g; pIter(g))
       {
-        assume(wDeg(g,polynomialRing,w)<d);
-        inequalities.appendRow(leadexpv-tailexpv);
+        p_GetExpV(g,expv,polynomialRing);
+        gfan::ZVector tailexpv = intStar2ZVector(n,expv);
+        if (wDeg(g,polynomialRing,w)==d)
+          equations.appendRow(leadexpv-tailexpv);
+        else
+        {
+          assume(wDeg(g,polynomialRing,w)<d);
+          inequalities.appendRow(leadexpv-tailexpv);
+        }
       }
     }
   }
   omFreeSize(expv,(n+1)*sizeof(int));
+  if (currentStrategy->restrictToLowerHalfSpace())
+  {
+    gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
+    lowerHalfSpaceCondition[0] = -1;
+    inequalities.appendRow(lowerHalfSpaceCondition);
+  }
 
   polyhedralCone = gfan::ZCone(inequalities,equations);
+  polyhedralCone.canonicalize();
   interiorPoint = polyhedralCone.getRelativeInteriorPoint();
   assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
@@ -159 +182 @@
   if (I) polynomialIdeal = id_Copy(I,r);
   if (r) polynomialRing = rCopy(r);
+  currentCase.reduce(I,r);
 
   int n = rVar(r);
@@ -167 +191 @@
   {
     poly g = polynomialIdeal->m[i];
-    p_GetExpV(g,expv,polynomialRing);
-    gfan::ZVector leadexpv = intStar2ZVector(n,expv);
-    long d1 = wDeg(g,polynomialRing,u);
-    long d2 = wDeg(g,polynomialRing,w);
-    for (pIter(g); g; pIter(g))
+    if (g)
     {
       p_GetExpV(g,expv,polynomialRing);
-      gfan::ZVector tailexpv = intStar2ZVector(n,expv);
-      if (wDeg(g,polynomialRing,u)==d1 && wDeg(g,polynomialRing,w)==d2)
-        equations.appendRow(leadexpv-tailexpv);
-      else
+      gfan::ZVector leadexpv = intStar2ZVector(n,expv);
+      long d1 = wDeg(g,polynomialRing,u);
+      long d2 = wDeg(g,polynomialRing,w);
+      for (pIter(g); g; pIter(g))
       {
-        assume(wDeg(g,polynomialRing,u)<d1 || wDeg(g,polynomialRing,w)<d2);
-        inequalities.appendRow(leadexpv-tailexpv);
+        p_GetExpV(g,expv,polynomialRing);
+        gfan::ZVector tailexpv = intStar2ZVector(n,expv);
+        if (wDeg(g,polynomialRing,u)==d1 && wDeg(g,polynomialRing,w)==d2)
+          equations.appendRow(leadexpv-tailexpv);
+        else
+        {
+          assume(wDeg(g,polynomialRing,u)<d1 || wDeg(g,polynomialRing,w)<d2);
+          inequalities.appendRow(leadexpv-tailexpv);
+        }
       }
     }
   }
   omFreeSize(expv,(n+1)*sizeof(int));
+  if (currentStrategy->restrictToLowerHalfSpace())
+  {
+    gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
+    lowerHalfSpaceCondition[0] = -1;
+    inequalities.appendRow(lowerHalfSpaceCondition);
+  }
 
   polyhedralCone = gfan::ZCone(inequalities,equations);
+  polyhedralCone.canonicalize();
   interiorPoint = polyhedralCone.getRelativeInteriorPoint();
   assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
@@ -205 +239 @@
   {
     poly g = inI->m[i];
-    p_GetExpV(g,expv,r);
-    gfan::ZVector leadexpv = intStar2ZVector(n,expv);
-    for (pIter(g); g; pIter(g))
+    if (g)
     {
       p_GetExpV(g,expv,r);
-      gfan::ZVector tailexpv = intStar2ZVector(n,expv);
-      equations.appendRow(leadexpv-tailexpv);
+      gfan::ZVector leadexpv = intStar2ZVector(n,expv);
+      for (pIter(g); g; pIter(g))
+      {
+        p_GetExpV(g,expv,r);
+        gfan::ZVector tailexpv = intStar2ZVector(n,expv);
+        equations.appendRow(leadexpv-tailexpv);
+      }
     }
   }
@@ -218 +255 @@
   {
     poly g = I->m[i];
-    p_GetExpV(g,expv,r);
-    gfan::ZVector leadexpv = intStar2ZVector(n,expv);
-    for (pIter(g); g; pIter(g))
+    if (g)
     {
       p_GetExpV(g,expv,r);
-      gfan::ZVector tailexpv = intStar2ZVector(n,expv);
-      inequalities.appendRow(leadexpv-tailexpv);
+      gfan::ZVector leadexpv = intStar2ZVector(n,expv);
+      for (pIter(g); g; pIter(g))
+      {
+        p_GetExpV(g,expv,r);
+        gfan::ZVector tailexpv = intStar2ZVector(n,expv);
+        inequalities.appendRow(leadexpv-tailexpv);
+      }
     }
   }
   omFreeSize(expv,(n+1)*sizeof(int));
+  if (currentStrategy->restrictToLowerHalfSpace())
+  {
+    gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
+    lowerHalfSpaceCondition[0] = -1;
+    inequalities.appendRow(lowerHalfSpaceCondition);
+  }
 
   polyhedralCone = gfan::ZCone(inequalities,equations);
+  polyhedralCone.canonicalize();
   interiorPoint = polyhedralCone.getRelativeInteriorPoint();
   assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
@@ -277 +324 @@
 gfan::ZVector groebnerCone::tropicalPoint() const
 {
+  assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
   ideal I = polynomialIdeal;
   ring r = polynomialRing;
-  gfan::ZCone zc = polyhedralCone;
-  gfan::ZMatrix R = zc.extremeRays();
-  assume(checkOrderingAndCone(r,zc));
+
+  gfan::ZCone coneToCheck = polyhedralCone;
+  gfan::ZMatrix R = coneToCheck.extremeRays();
   for (int i=0; i<R.getHeight(); i++)
   {
-    ideal inI = initial(I,r,R[i]);
-    poly s = checkForMonomialViaSuddenSaturation(inI,r);
-    if (s == NULL)
-    {
-      id_Delete(&inI,r);
+    assume(!currentStrategy->restrictToLowerHalfSpace() || R[i][0].sign()<=0);
+    poly s = currentStrategy->checkInitialIdealForMonomial(I,r,R[i]);
+    if (s==NULL)
+    {
       p_Delete(&s,r);
       return R[i];
     }
-    id_Delete(&inI,r);
-    p_Delete(&s,r);
   }
   return gfan::ZVector();
@@ -346 +391 @@
    *   to obtain an initial form with respect to interiorPoint+e*facetNormal,
    *   for e>0 sufficiently small */
-  std::pair<ideal,ring> flipped = flip(polynomialIdeal,polynomialRing,interiorPoint,facetNormal,*currentStrategy);
+  std::pair<ideal,ring> flipped = currentStrategy->flip(polynomialIdeal,polynomialRing,interiorPoint,facetNormal);
+  std::cout << "finished flip" << std::endl;
   assume(checkPolynomialInput(flipped.first,flipped.second));
   groebnerCone flippedCone(flipped.first, flipped.second, interiorPoint, facetNormal, *currentStrategy);
@@ -417 +463 @@
   groebnerCones neighbours;
   for (int i=0; i<interiorPoints.getHeight(); i++)
+  {
+    std::cout << "performing flip " << i << " out of " << interiorPoints.getHeight() << std::endl;
     neighbours.insert(this->flipCone(interiorPoints[i],facetNormals[i]));
-
+  }
   return neighbours;
 }
@@ -477 +525 @@
   for (int i=0; i<interiorPoints.getHeight(); i++)
   {
-    ideal initialIdeal = initial(polynomialIdeal,polynomialRing,interiorPoints[i]);
-    std::set<gfan::ZVector> rays = raysOfTropicalStar(initialIdeal,polynomialRing,interiorPoints[i],*currentStrategy);
-    for (std::set<gfan::ZVector>::iterator ray = rays.begin(); ray!=rays.end(); ray++)
-      neighbours.insert(this->flipCone(interiorPoints[i],*ray));
+    if (!(currentStrategy->restrictToLowerHalfSpace() && interiorPoints[i][0].sign()==0))
+    {
+      ideal initialIdeal = initial(polynomialIdeal,polynomialRing,interiorPoints[i]);
+      std::set<gfan::ZVector> rays = raysOfTropicalStar(initialIdeal,polynomialRing,interiorPoints[i],*currentStrategy);
+      for (std::set<gfan::ZVector>::iterator ray = rays.begin(); ray!=rays.end(); ray++)
+        neighbours.insert(this->flipCone(interiorPoints[i],*ray));
+    }
   }
   return neighbours;

Singular/dyn_modules/gfanlib/groebnerCone.h

@@ -40 +40 @@
   gfan::ZCone polyhedralCone;
   gfan::ZVector interiorPoint;
+  gfan::ZVector negativePointInLineality;
   const tropicalStrategy* currentStrategy;
 
@@ -69 +70 @@
   gfan::ZCone getPolyhedralCone() const { return polyhedralCone; };
   gfan::ZVector getInteriorPoint() const { return interiorPoint; };
+  gfan::ZVector getNegativePointInLineality() const { return negativePointInLineality; };
   const tropicalStrategy* getTropicalStrategy() const {return currentStrategy; };
 

Singular/dyn_modules/gfanlib/initial.cc

@@ -128 +128 @@
 ideal initial(const ideal I, const ring r, const gfan::ZVector w)
 {
+  idSkipZeroes(I);
   int k = idSize(I); ideal inI = idInit(k);
   for (int i=0; i<k; i++)

Singular/dyn_modules/gfanlib/neighbours.cc

@@ -178 +178 @@
   gfan::ZMatrix interiorPoints = facetInteriorPoints(zc);
   groebnerCones neighbours;
-  bool (*red)(ideal I, ring r, number p);
-  red = currentCase.reduce;
-  number p = currentCase.uniformizingParameter;
 
   for (int i=0; i<interiorPoints.getHeight(); i++)
@@ -196 +193 @@
       ideal I = flipped.first;
       ring r = flipped.second;
-      red(I,r,p);
+      currentCase->reduce(I,r);
       gfan::ZCone c = sloppyGroebnerCone(I,r,*ray);
       gfan::ZVector p = c.getRelativeInteriorPoint();

Singular/dyn_modules/gfanlib/ppinitialReduction.cc

@@ -21 +21 @@
   if (g==NULL)
     return false;
+  p_Test(g,r);
 
   poly toBeChecked = pNext(g);
@@ -43 +44 @@
       if (n_DivBy(p_GetCoeff(toBeChecked,r),p,r->cf))
       {
+        power=1;
         coeff=n_Div(p_GetCoeff(toBeChecked,r),p,r->cf);
-        power=1;
         while (n_DivBy(coeff,p,r->cf))
         {
-          coeff=n_Div(p_GetCoeff(pNext(g),r),p,r->cf);
           power++;
+          number coeff0 = n_Div(coeff,p,r->cf);
+          n_Delete(&coeff,r->cf);
+          coeff = coeff0;
+          coeff0 = NULL;
           if (power<1)
           {
@@ -68 +72 @@
         pIter(gEnd); pIter(toBeChecked);
         pNext(gEnd)=NULL;
+        p_Test(g,r);
       }
     }
@@ -193 +198 @@
     n=j;
   } while(n);
-  for (int i=1; i<m; i++)
+  for (int i=0; i<m; i++)
     if (pReduce(I->m[i],p,r)) return true;
 
@@ -257 +262 @@
 bool ppreduceInitially(ideal I, const number p, const poly g, const ring r)
 {
+  idInsertPoly(I,g);
   int n=idSize(I);
-  idInsertPoly(I,g);
   int j;
-  for (j=n; j>0; j--)
+  for (j=n-1; j>0; j--)
   {
     if (p_LmCmp(I->m[j], I->m[j-1],r)>0)
@@ -370 +375 @@
       {
         g=T->m[i-1];
-        T->m[i-1]=I->m[i];
+        T->m[i-1]=T->m[i];
         T->m[i]=g;
         j = i;
@@ -389 +394 @@
     if (i<k)
     {
-      g = p_Init(r);
+      g = p_One(r);
       for (int j=2; j<=r->N; j++)
         p_SetExp(g,j,p_GetExp(pNext(T->m[0]),j,r)-p_GetExp(G->m[i],j,r),r);
-      p_SetCoeff(g,n_Init(1,r->cf),r); p_Setm(g,r);
+      p_Setm(g,r);
       g = p_Mult_q(g,p_Copy(G->m[i],r),r);
       ppreduceInitially(I,p,g,r);
@@ -504 +509 @@
   for (int i=0; i<n; i++)
   {
+    I->m[i] = p_Cleardenom(I->m[i],r);
     long d = 0;
     for (int j=2; j<=r->N; j++)

Singular/dyn_modules/gfanlib/startingCone.cc

@@ -11 +11 @@
 #include <tropicalVarietyOfPolynomials.h>
 #include <tropicalVariety.h>
+#include <tropicalStrategy.h>
 
 
@@ -23 +24 @@
   ideal I = sigma.getPolynomialIdeal();
   ring r = sigma.getPolynomialRing();
-  ideal inI = sloppyInitial(I,r,w);
-  poly s = checkForMonomialViaSuddenSaturation(inI,r);
-  id_Delete(&inI,r);
+  const tropicalStrategy* currentStrategy = sigma.getTropicalStrategy();
+  poly s = currentStrategy->checkInitialIdealForMonomial(I,r,w);
   if (s)
   {
@@ -44 +44 @@
 
 
-/***
- * Computes a starting point by traversing the Groebner fan,
+/**
+ * Computes a starting point outside the lineatliy space by traversing the Groebner fan,
  * checking each cone whether it contains a ray in the tropical variety.
- * Returns a point in the tropical variety and a maximal Groebner cone
- * containing the point.
+ * Returns a point in the tropical variety and a maximal Groebner cone containing the point.
  **/
 std::pair<gfan::ZVector,groebnerCone> tropicalStartingDataViaGroebnerFan(const ideal I, const ring r, const tropicalStrategy& currentStrategy)
 {
-  std::cout << "computing starting cone" << std::endl;
-  currentStrategy.reduce(I,r);
-  std::cout << "finished reduction" << std::endl;
-
+  // start by computing a maximal Groebner cone and
+  // check whether one of its rays lies in the tropical variety
   const groebnerCone sigma(I,r,currentStrategy);
-  std::cout << "finished first maximal Groebner cone" << std::endl;
   gfan::ZVector startingPoint = sigma.tropicalPoint();
   if (startingPoint.size() > 0)
     return std::make_pair(startingPoint,sigma);
+
+  // if not, traverse the groebnerFan and until such a cone is found
+  // and return the maximal cone together with a point in its ray
   groebnerCones groebnerFan;
   groebnerCones workingList;
   workingList.insert(sigma);
-
   while (!workingList.empty())
   {
-    std::cout << "traversing groebner fan..." << std::endl;
     const groebnerCone sigma = *(workingList.begin());
     groebnerCones neighbours = sigma.groebnerNeighbours();
@@ -86 +83 @@
     workingList.erase(sigma);
   }
+
+  // return some trivial output, if such a cone cannot be found
   gfan::ZVector emptyVector = gfan::ZVector(0);
   groebnerCone emptyCone = groebnerCone();
@@ -264 +263 @@
     }
     gfan::ZCone C0 = currentStrategy.getHomogeneitySpace();
-    if (C0.dimension()==currentStrategy.getDimensionOfIdeal())
+    if (C0.dimension()==currentStrategy.getExpectedDimension())
     {
       gfan::ZMatrix lin = C0.generatorsOfLinealitySpace();
@@ -293 +292 @@
   {
     poly g = I->m[i];
-    p_GetExpV(g,expv,r);
-    gfan::ZVector leadexp = intStar2ZVector(n,expv);
-    for (pIter(g); g; pIter(g))
+    if (g)
     {
       p_GetExpV(g,expv,r);
-      equations.appendRow(leadexp-intStar2ZVector(n,expv));
+      gfan::ZVector leadexp = intStar2ZVector(n,expv);
+      for (pIter(g); g; pIter(g))
+      {
+        p_GetExpV(g,expv,r);
+        equations.appendRow(leadexp-intStar2ZVector(n,expv));
+      }
     }
   }
@@ -304 +306 @@
   return gfan::ZCone(gfan::ZMatrix(0,n),equations);
 }
-
 
 /***
  * Computes a starting cone in the tropical variety.
  **/
-groebnerCone tropicalStartingCone(const ideal I, const ring r, const tropicalStrategy& currentStrategy)
-{
-  ring s = rCopy(r);
-  int k = idSize(I); ideal inI = 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);
-
-  gfan::ZCone zc = linealitySpaceOfGroebnerFan(inI,s);
-  gfan::ZVector startingPoint; groebnerCone ambientMaximalCone;
-  while (zc.dimension()<currentStrategy.getDimensionOfIdeal())
-  {
+groebnerCone tropicalStartingCone(const tropicalStrategy& currentStrategy)
+{
+  ring r = currentStrategy.getStartingRing();
+  ideal I = currentStrategy.getStartingIdeal();
+  if (currentStrategy.isConstantCoefficientCase())
+  {
+    // copy the data, so that it be deleted when passed to the loop
+    // s <- r
+    // inI <- I
+    ring s = rCopy(r);
+    int k = idSize(I); ideal inI = 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);
+
+    // repeatedly computes a point in the tropical variety outside the lineality space,
+    // take the initial ideal with respect to it
+    // and check whether the dimension of its homogeneity space
+    // equals the dimension of the tropical variety
+    gfan::ZCone zc = linealitySpaceOfGroebnerFan(inI,s);
+    gfan::ZVector startingPoint; groebnerCone ambientMaximalCone;
+    while (zc.dimension()<currentStrategy.getExpectedDimension())
+    {
+      // compute a point in the tropical variety outside the lineality space
+      std::pair<gfan::ZVector,groebnerCone> startingData = tropicalStartingDataViaGroebnerFan(inI,s,currentStrategy);
+      startingPoint = startingData.first;
+      ambientMaximalCone = groebnerCone(startingData.second);
+
+      id_Delete(&inI,s); rDelete(s);
+      inI = ambientMaximalCone.getPolynomialIdeal();
+      s = ambientMaximalCone.getPolynomialRing();
+
+      // compute the initial ideal with respect to the weight
+      inI = sloppyInitial(inI,s,startingPoint);
+      zc = linealitySpaceOfGroebnerFan(inI,s);
+    }
+
+    // once the dimension of the homogeneity space equals that of the tropical variety
+    // we know that we have an initial ideal with respect to a weight
+    // in the relative interior of a maximal cone in the tropical variety
+    // from this we can read of the inequalities and equations
+
+    // but before doing so, we must lift the generating set of inI
+    // to a generating set of I
+    ideal J = lift(I,r,inI,s);
+    groebnerCone startingCone(J,inI,s,currentStrategy);
+    id_Delete(&inI,s);
+    id_Delete(&J,s);
+
+    assume(checkContainmentInTropicalVariety(startingCone));
+    return startingCone;
+  }
+  else
+  {
+    // copy the data, so that it be deleted when passed to the loop
+    // s <- r
+    // inI <- I
+    ring s = rCopy(r);
+    int k = idSize(I); ideal inI = 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);
+
+    // and check whether the dimension of its homogeneity space
+    // equals the dimension of the tropical variety
+    gfan::ZCone zc = linealitySpaceOfGroebnerFan(inI,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);
+      rDelete(s);
+      return startingCone;
+    }
+
+    // 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);
-    startingPoint = startingData.first;
-    ambientMaximalCone = groebnerCone(startingData.second);
-
+    gfan::ZVector startingPoint = startingData.first;
+    groebnerCone ambientMaximalCone = groebnerCone(startingData.second);
     id_Delete(&inI,s); rDelete(s);
     inI = ambientMaximalCone.getPolynomialIdeal();
     s = ambientMaximalCone.getPolynomialRing();
-
     inI = sloppyInitial(inI,s,startingPoint);
     zc = linealitySpaceOfGroebnerFan(inI,s);
-  }
-
-  ideal J = lift(I,r,inI,s);
-  groebnerCone tropicalStartingCone(J,inI,s,currentStrategy);
-  id_Delete(&inI,s);
-  id_Delete(&J,s);
-
-  assume(checkContainmentInTropicalVariety(tropicalStartingCone));
-  assume(checkOneCodimensionalLinealitySpace(tropicalStartingCone));
-  return tropicalStartingCone;
-}
-
+
+    // and check whether the dimension of its homogeneity space
+    // equals the dimension of the tropical variety
+    if (zc.dimension()==currentStrategy.getExpectedDimension())
+    { // 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);
+      id_Delete(&J,s);
+      return startingCone;
+    }
+
+    // from this point on, inI 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
+    ring rShortcut = rCopy0(r);
+    nKillChar(rShortcut->cf);
+    rShortcut->cf = nCopyCoeff((currentStrategy.getShortcutRing())->cf);
+    rComplete(rShortcut);
+    rTest(rShortcut);
+    k = idSize(inI);
+    ideal inIShortcut = 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
+    // 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);
+    groebnerCone startingConeShortcut = tropicalStartingCone(shortcutStrategy);
+    id_Delete(&inIShortcut,rShortcut); rDelete(rShortcut);
+
+    // now we need to obtain the initial of the residue of inI
+    // with respect to a weight in the tropical cone,
+    // and obtain the initial of inI with respect to the same weight
+    ring sShortcut = startingConeShortcut.getPolynomialRing();
+    inIShortcut = startingConeShortcut.getPolynomialIdeal();
+    gfan::ZCone zd = startingConeShortcut.getPolyhedralCone();
+    gfan::ZVector interiorPoint = startingConeShortcut.getInteriorPoint();
+    inIShortcut = sloppyInitial(inIShortcut,sShortcut,interiorPoint);
+
+    s = rCopy0(sShortcut); // s will be a ring over the valuation ring
+    nKillChar(s->cf);      // with the same ordering as sShortcut
+    s->cf = nCopyCoeff(r->cf);
+    rComplete(s);
+    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
+    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);
+    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);
+    groebnerCone startingCone(J,inI,s,currentStrategy);
+    id_Delete(&inI,s);
+    id_Delete(&J,s);
+    rDelete(s);
+
+    return startingCone;
+  }
+}
 
 BOOLEAN tropicalStartingCone(leftv res, leftv args)
@@ -357 +479 @@
       if (w==NULL)
       {
-        tropicalStrategy valuedCase(I,p,currRing);
-        groebnerCone sigma = tropicalStartingCone(I,currRing,valuedCase);
+        tropicalStrategy currentStrategy(I,p,currRing);
+        groebnerCone sigma = tropicalStartingCone(currentStrategy);
+        gfan::ZCone* startingCone = new gfan::ZCone(sigma.getPolyhedralCone());
+        res->rtyp = coneID;
+        res->data = (char*) startingCone;
+        return FALSE;
+      }
+    }
+    else
+    {
+      if (v==NULL)
+      {
+        tropicalStrategy currentStrategy(I,currRing);
+        groebnerCone sigma = tropicalStartingCone(currentStrategy);
         res->rtyp = coneID;
         res->data = (char*) new gfan::ZCone(sigma.getPolyhedralCone());
@@ -364 +498 @@
       }
     }
-    else
-    {
-      if (v==NULL)
-      {
-        tropicalStrategy nonValuedCase(I,currRing);
-        groebnerCone sigma = tropicalStartingCone(I,currRing,nonValuedCase);
-        res->rtyp = coneID;
-        res->data = (char*) new gfan::ZCone(sigma.getPolyhedralCone());
-        return FALSE;
-      }
-    }
   }
   WerrorS("tropicalStartingCone: unexpected parameters");

Singular/dyn_modules/gfanlib/startingCone.h

@@ -5 +5 @@
 #include <tropicalStrategy.h>
 
-groebnerCone tropicalStartingCone(const ideal I, const ring r, const tropicalStrategy& currentCase);
+groebnerCone tropicalStartingCone(const tropicalStrategy& currentCase);
 
 BOOLEAN tropicalStartingPoint(leftv res, leftv args);

Singular/dyn_modules/gfanlib/tropical.cc

@@ -27 +27 @@
   for (int i=0; i<IDELEMS(I); i++)
   {
-    g = (poly) I->m[i]; pGetExpV(g,leadexpv);
-    leadexpw = intStar2ZVector(n, leadexpv);
-    pIter(g);
-    while (g != NULL)
-    {
-      pGetExpV(g,tailexpv);
-      tailexpw = intStar2ZVector(n, tailexpv);
-      equations.appendRow(leadexpw-tailexpw);
+    g = (poly) I->m[i];
+    if (g)
+    {
+      p_GetExpV(g,leadexpv,r);
+      leadexpw = intStar2ZVector(n,leadexpv);
       pIter(g);
+      while (g)
+      {
+        p_GetExpV(g,tailexpv,r);
+        tailexpw = intStar2ZVector(n,tailexpv);
+        equations.appendRow(leadexpw-tailexpw);
+        pIter(g);
+      }
     }
   }

Singular/dyn_modules/gfanlib/tropicalCurves.cc

@@ -100 +100 @@
 
   /* complete the ring and return it */
-  rComplete(s,1);
+  rComplete(s);
+  rTest(s);
   return s;
 }
@@ -114 +115 @@
 {
   int k = idSize(inI);
-  int d = currentStrategy.getDimensionOfIdeal();
+  int d = currentStrategy.getExpectedDimension();
 
   /* Compute the common refinement over all tropical varieties
@@ -168 +169 @@
   std::set<gfan::ZCone> C = tropicalStar(I,r,u,currentStrategy);
   std::set<gfan::ZVector> raysOfC;
-  for (std::set<gfan::ZCone>::iterator zc=C.begin(); zc!=C.end(); zc++)
-  {
-    assume(zc->dimensionOfLinealitySpace()+1 == zc->dimension());
-    raysOfC.insert(zc->semiGroupGeneratorOfRay());
+  if (!currentStrategy.restrictToLowerHalfSpace())
+  {
+    for (std::set<gfan::ZCone>::iterator zc=C.begin(); zc!=C.end(); zc++)
+    {
+      assume(zc->dimensionOfLinealitySpace()+1 == zc->dimension());
+      raysOfC.insert(zc->semiGroupGeneratorOfRay());
+    }
+  }
+  else
+  {
+    for (std::set<gfan::ZCone>::iterator zc=C.begin(); zc!=C.end(); zc++)
+    {
+      assume(zc->dimensionOfLinealitySpace()+2 == zc->dimension());
+      raysOfC.insert(zc->getRelativeInteriorPoint());
+    }
   }
   return raysOfC;

Singular/dyn_modules/gfanlib/tropicalStrategy.cc

@@ -49 +49 @@
  *g
  */
-tropicalStrategy::tropicalStrategy(ideal I, ring r):
+tropicalStrategy::tropicalStrategy(const ideal I, const ring r,
+                                   const bool completelyHomogeneous,
+                                   const bool completeSpace):
   originalRing(rCopy(r)),
   originalIdeal(id_Copy(I,r)),
-  dimensionOfIdeal(dim(originalIdeal,originalRing)),
+  expectedDimension(dim(originalIdeal,originalRing)),
   linealitySpace(homogeneitySpace(originalIdeal,originalRing)),
   startingRing(rCopy(originalRing)),
@@ -63 +65 @@
   extraReductionAlgorithm(noExtraReduction)
 {
-  assume(rField_is_Q(r));
+  assume(rField_is_Q(r) || rField_is_Zp(r));
+  if (!completelyHomogeneous)
+  {
+    weightAdjustingAlgorithm1 = valued_adjustWeightForHomogeneity;
+    weightAdjustingAlgorithm2 = valued_adjustWeightUnderHomogeneity;
+  }
+  if (!completeSpace)
+    onlyLowerHalfSpace = true;
 }
 
@@ -101 +110 @@
 
   rComplete(s);
+  rTest(s);
   return s;
 }
@@ -111 +121 @@
     ring s = rCopy0(r,FALSE,TRUE);
     rComplete(s);
+    rTest(s);
     return s;
   }
@@ -123 +134 @@
   originalRing(rCopy(s)),
   originalIdeal(id_Copy(J,s)),
-  dimensionOfIdeal(dim(originalIdeal,originalRing)),
-  linealitySpace(homogeneitySpace(originalIdeal,originalRing)),
-  startingRing(rCopy(originalRing)),
-  startingIdeal(id_Copy(originalIdeal,originalRing)),
-  uniformizingParameter(NULL),
-  shortcutRing(rCopy(originalRing)),
-  onlyLowerHalfSpace(false),
-  weightAdjustingAlgorithm1(nonvalued_adjustWeightForHomogeneity),
-  weightAdjustingAlgorithm2(nonvalued_adjustWeightUnderHomogeneity),
-  extraReductionAlgorithm(noExtraReduction)
+  expectedDimension(dim(originalIdeal,originalRing)+1),
+  linealitySpace(gfan::ZCone()), // to come, see below
+  startingRing(NULL),            // to come, see below
+  startingIdeal(NULL),           // to come, see below
+  uniformizingParameter(NULL),   // to come, see below
+  shortcutRing(NULL),            // to come, see below
+  onlyLowerHalfSpace(true),
+  weightAdjustingAlgorithm1(valued_adjustWeightForHomogeneity),
+  weightAdjustingAlgorithm2(valued_adjustWeightUnderHomogeneity),
+  extraReductionAlgorithm(ppreduceInitially)
 {
   /* assume that the ground field of the originalRing is Q */
@@ -164 +175 @@
   omFreeSize(shiftByOne,(n+1)*sizeof(int));
 
+  linealitySpace = homogeneitySpace(startingIdeal,startingRing);
+
   /* construct the shorcut ring */
   shortcutRing = rCopy0(startingRing);
@@ -169 +182 @@
   shortcutRing->cf = nInitChar(n_Zp,(void*)(long)IsPrime(n_Int(uniformizingParameter,startingRing->cf)));
   rComplete(shortcutRing);
-
-  /* compute the dimension of the ideal in the original ring */
-  dimensionOfIdeal = dim(J,s);
-
-  /* set the flag that convex computations only occur in the lower half space to true */
-  onlyLowerHalfSpace = true;
-
-  /* set the function pointers to the appropiate functions */
-  weightAdjustingAlgorithm1 = valued_adjustWeightForHomogeneity;
-  weightAdjustingAlgorithm2 = valued_adjustWeightUnderHomogeneity;
-  extraReductionAlgorithm = ppreduceInitially;
+  rTest(shortcutRing);
 }
 
 tropicalStrategy::tropicalStrategy(const tropicalStrategy& currentStrategy):
   originalRing(rCopy(currentStrategy.getOriginalRing())),
+  originalIdeal(id_Copy(currentStrategy.getOriginalIdeal(),currentStrategy.getOriginalRing())),
+  expectedDimension(currentStrategy.getExpectedDimension()),
+  linealitySpace(currentStrategy.getHomogeneitySpace()),
   startingRing(rCopy(currentStrategy.getStartingRing())),
+  startingIdeal(id_Copy(currentStrategy.getStartingIdeal(),currentStrategy.getStartingRing())),
   uniformizingParameter(n_Copy(currentStrategy.getUniformizingParameter(),startingRing->cf)),
-  startingIdeal(id_Copy(currentStrategy.getStartingIdeal(),startingRing)),
-  dimensionOfIdeal(currentStrategy.getDimensionOfIdeal()),
+  shortcutRing(rCopy(currentStrategy.getShortcutRing())),
   onlyLowerHalfSpace(currentStrategy.restrictToLowerHalfSpace()),
   weightAdjustingAlgorithm1(currentStrategy.weightAdjustingAlgorithm1),
@@ -193 +199 @@
   extraReductionAlgorithm(currentStrategy.extraReductionAlgorithm)
 {
+  if (originalRing) rTest(originalRing);
+  if (originalIdeal) id_Test(originalIdeal,originalRing);
   if (startingRing) rTest(startingRing);
   if (startingIdeal) id_Test(startingIdeal,startingRing);
+  if (uniformizingParameter) n_Test(uniformizingParameter,startingRing->cf);
+  if (shortcutRing) rTest(shortcutRing);
 }
 
 tropicalStrategy::~tropicalStrategy()
 {
+  if (originalRing) rTest(originalRing);
+  if (originalIdeal) id_Test(originalIdeal,originalRing);
   if (startingRing) rTest(startingRing);
   if (startingIdeal) id_Test(startingIdeal,startingRing);
-
+  if (uniformizingParameter) n_Test(uniformizingParameter,startingRing->cf);
+  if (shortcutRing) rTest(shortcutRing);
+
+  id_Delete(&originalIdeal,originalRing);
+  rDelete(originalRing);
   id_Delete(&startingIdeal,startingRing);
   n_Delete(&uniformizingParameter,startingRing->cf);
-  rDelete(originalRing);
   rDelete(startingRing);
+  rDelete(shortcutRing);
 }
 
@@ -211 +227 @@
 {
   originalRing = rCopy(currentStrategy.getOriginalRing());
+  originalIdeal = id_Copy(currentStrategy.getOriginalIdeal(),currentStrategy.getOriginalRing());
+  expectedDimension = currentStrategy.getExpectedDimension();
   startingRing = rCopy(currentStrategy.getStartingRing());
+  startingIdeal = id_Copy(currentStrategy.getStartingIdeal(),currentStrategy.getStartingRing());
   uniformizingParameter = n_Copy(currentStrategy.getUniformizingParameter(),startingRing->cf);
-  startingIdeal = id_Copy(currentStrategy.getStartingIdeal(),startingRing);
-  dimensionOfIdeal = currentStrategy.getDimensionOfIdeal();
+  shortcutRing = rCopy(currentStrategy.getShortcutRing());
   onlyLowerHalfSpace = currentStrategy.restrictToLowerHalfSpace();
   weightAdjustingAlgorithm1 = currentStrategy.weightAdjustingAlgorithm1;
@@ -220 +238 @@
   extraReductionAlgorithm = currentStrategy.extraReductionAlgorithm;
 
+  if (originalRing) rTest(originalRing);
+  if (originalIdeal) id_Test(originalIdeal,originalRing);
   if (startingRing) rTest(startingRing);
   if (startingIdeal) id_Test(startingIdeal,startingRing);
+  if (uniformizingParameter) n_Test(uniformizingParameter,startingRing->cf);
+  if (shortcutRing) rTest(shortcutRing);
 
   return *this;

Singular/dyn_modules/gfanlib/tropicalStrategy.h

@@ -5 +5 @@
 #include <gfanlib/gfanlib_zcone.h>
 #include <libpolys/polys/simpleideals.h>
+#include <kernel/ideals.h> // for idSize
 #include <set>
+#include <callgfanlib_conversion.h>
+#include <containsMonomial.h>
+#include <flip.h>
+#include <initial.h>
 
 /** \file
@@ -33 +38 @@
   ideal originalIdeal;
   /**
-   * dimension of the input ideal
-   */
-  int dimensionOfIdeal;
+   * 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
+   * (as the output is supposed to be intersected with a hyperplane)
+   */
+  int expectedDimension;
   /**
    * the homogeneity space of the Grobner fan
@@ -87 +95 @@
    * Constructor for the trivial valuation case
    */
-  tropicalStrategy(const ideal I, const ring r);
+  tropicalStrategy(const ideal I, const ring r, const bool completelyHomogeneous=true, const bool completeSpace=true);
   /**
    * Constructor for the non-trivial valuation case
@@ -106 +114 @@
   tropicalStrategy& operator=(const tropicalStrategy& currentStrategy);
 
+  bool isConstantCoefficientCase() const
+  {
+    bool b = (uniformizingParameter==NULL);
+    return b;
+  }
 
   /**
@@ -117 +130 @@
 
   /**
+   * returns the input ideal over the field with valuation
+   */
+  ideal getOriginalIdeal() const
+  {
+    if (originalIdeal) id_Test(originalIdeal,originalRing);
+    return originalIdeal;
+  }
+
+  /**
    * returns the polynomial ring over the valuation ring
    */
@@ -130 +152 @@
   ideal getStartingIdeal() const
   {
-    id_Test(startingIdeal,startingRing);
+    if (startingIdeal) id_Test(startingIdeal,startingRing);
     return startingIdeal;
   }
 
   /**
-   * returns the dimension of the input ideal
-   */
-  int getDimensionOfIdeal() const
-  {
-    return dimensionOfIdeal;
+   * returns the expected Dimension of the polyhedral output
+   */
+  int getExpectedDimension() const
+  {
+    return expectedDimension;
   }
 
@@ -147 +169 @@
   number getUniformizingParameter() const
   {
+    if (uniformizingParameter) n_Test(uniformizingParameter,startingRing->cf);
     return uniformizingParameter;
+  }
+
+  ring getShortcutRing() const
+  {
+    rTest(shortcutRing);
+    return shortcutRing;
   }
 
@@ -198 +227 @@
    * the inequalities and equations of the Groebner cone can be read off.
    */
-  bool reduce(ideal I, ring r) const
+  bool reduce(ideal I, const ring r) const
   {
     rTest(r);  id_Test(I,r);
@@ -212 +241 @@
    * returns false otherwise.
    **/
-  bool containsMonomial(ideal I, ring r) const
-  {
-    ring rFinite = rCopy0(r);
-    nKillChar(rFinite.coeffs());
-    rFinite->cf =
+  poly checkInitialIdealForMonomial(const ideal I, const ring r, const gfan::ZVector w) const
+  {
+    gfan::ZVector v = adjustWeightForHomogeneity(w);
+    if (isConstantCoefficientCase())
+    {
+      ring rShortcut = rCopy0(r);
+      bool overflow;
+      /**
+       * prepend extra weight vector for homogeneity
+       */
+      int* order = rShortcut->order;
+      int* block0 = rShortcut->block0;
+      int* block1 = rShortcut->block1;
+      int** wvhdl = rShortcut->wvhdl;
+      int h = rBlocks(r); int n = rVar(r);
+      rShortcut->order = (int*) omAlloc0((h+1)*sizeof(int));
+      rShortcut->block0 = (int*) omAlloc0((h+1)*sizeof(int));
+      rShortcut->block1 = (int*) omAlloc0((h+1)*sizeof(int));
+      rShortcut->wvhdl = (int**) omAlloc0((h+1)*sizeof(int*));
+      rShortcut->order[0] = ringorder_a;
+      rShortcut->block0[0] = 1;
+      rShortcut->block1[0] = n;
+      rShortcut->wvhdl[0] = ZVectorToIntStar(v,overflow);
+      for (int i=1; i<=h; i++)
+      {
+        rShortcut->order[i] = order[i-1];
+        rShortcut->block0[i] = block0[i-1];
+        rShortcut->block1[i] = block1[i-1];
+        rShortcut->wvhdl[i] = wvhdl[i-1];
+      }
+      rComplete(rShortcut);
+      rTest(rShortcut);
+      omFree(order);
+      omFree(block0);
+      omFree(block1);
+      omFree(wvhdl);
+
+      ideal inI = initial(I,r,w);
+      int k = idSize(inI);
+      ideal inIShortcut = idInit(k);
+      nMapFunc identity = n_SetMap(r->cf,rShortcut->cf);
+      for (int i=0; i<k; i++)
+        inIShortcut->m[i] = p_PermPoly(inI->m[i],NULL,r,rShortcut,identity,NULL,0);
+
+      poly p = checkForMonomialViaSuddenSaturation(inIShortcut,rShortcut);
+      poly monomial = NULL;
+      if (p!=NULL)
+      {
+        monomial=p_One(r);
+        for (int i=1; i<n; i++)
+          p_SetExp(monomial,i,p_GetExp(p,i,rShortcut),r);
+        p_Delete(&p,rShortcut);
+      }
+      id_Delete(&inI,r);
+      id_Delete(&inIShortcut,rShortcut);
+      rDelete(rShortcut);
+      return monomial;
+    }
+    else
+    {
+      ring rShortcut = rCopy0(r);
+      bool overflow;
+      /**
+       * prepend extra weight vector for homogeneity
+       */
+      int* order = rShortcut->order;
+      int* block0 = rShortcut->block0;
+      int* block1 = rShortcut->block1;
+      int** wvhdl = rShortcut->wvhdl;
+      int h = rBlocks(r); int n = rVar(r);
+      rShortcut->order = (int*) omAlloc0((h+1)*sizeof(int));
+      rShortcut->block0 = (int*) omAlloc0((h+1)*sizeof(int));
+      rShortcut->block1 = (int*) omAlloc0((h+1)*sizeof(int));
+      rShortcut->wvhdl = (int**) omAlloc0((h+1)*sizeof(int*));
+      rShortcut->order[0] = ringorder_a;
+      rShortcut->block0[0] = 1;
+      rShortcut->block1[0] = n;
+      rShortcut->wvhdl[0] = ZVectorToIntStar(v,overflow);
+      for (int i=1; i<=h; i++)
+      {
+        rShortcut->order[i] = order[i-1];
+        rShortcut->block0[i] = block0[i-1];
+        rShortcut->block1[i] = block1[i-1];
+        rShortcut->wvhdl[i] = wvhdl[i-1];
+      }
+      omFree(order);
+      omFree(block0);
+      omFree(block1);
+      omFree(wvhdl);
+      /**
+       * change ground domain into finite field
+       */
+      nKillChar(rShortcut->cf);
+      rShortcut->cf = nCopyCoeff(shortcutRing->cf);
+      rComplete(rShortcut);
+      rTest(rShortcut);
+
+      ideal inI = initial(I,r,w);
+      int k = idSize(inI);
+      ideal inIShortcut = idInit(k);
+      nMapFunc takingResidues = n_SetMap(r->cf,rShortcut->cf);
+      for (int i=0; i<k; i++)
+        inIShortcut->m[i] = p_PermPoly(inI->m[i],NULL,r,rShortcut,takingResidues,NULL,0);
+
+      idSkipZeroes(inIShortcut);
+      poly p = checkForMonomialViaSuddenSaturation(inIShortcut,rShortcut);
+      poly monomial = NULL;
+      if (p!=NULL)
+      {
+        monomial=p_One(r);
+        for (int i=1; i<n; i++)
+          p_SetExp(monomial,i,p_GetExp(p,i,rShortcut),r);
+        p_Delete(&p,rShortcut);
+      }
+      id_Delete(&inI,r);
+      id_Delete(&inIShortcut,rShortcut);
+      rDelete(rShortcut);
+      return monomial;
+    }
+  }
+  std::pair<ideal,ring> flip(const ideal I, const ring r,
+                             const gfan::ZVector interiorPoint,
+                             const gfan::ZVector facetNormal) const
+  {
+    gfan::ZVector adjustedInteriorPoint = adjustWeightForHomogeneity(interiorPoint);
+    gfan::ZVector adjustedFacetNormal = adjustWeightUnderHomogeneity(facetNormal,adjustedInteriorPoint);
+    return flip0(I,r,interiorPoint,facetNormal,adjustedInteriorPoint,adjustedFacetNormal);
   }
 };

Singular/dyn_modules/gfanlib/tropicalVariety.cc

@@ -37 +37 @@
     {
       tropicalStrategy currentStrategy(I,currRing);
+      setOptionRedSB();
       gfan::ZFan* tropI = tropicalVariety(currentStrategy);
+      undoSetOptionRedSB();
       res->rtyp = fanID;
       res->data = (char*) tropI;
@@ -46 +48 @@
       number p = (number) v->CopyD();
       tropicalStrategy currentStrategy(I,p,currRing);
-      setOptionRedSB();
       gfan::ZFan* tropI = tropicalVariety(currentStrategy);
-      undoSetOptionRedSB();
       res->rtyp = fanID;
       res->data = (char*) tropI;

Singular/dyn_modules/gfanlib/tropicalVarietyOfIdeals.cc

@@ -7 +7 @@
   ideal I = currentStrategy.getStartingIdeal();
   ring r = currentStrategy.getStartingRing();
-  groebnerCone startingCone = tropicalStartingCone(I,r,currentStrategy);
+  groebnerCone startingCone = tropicalStartingCone(currentStrategy);
   groebnerCones tropicalVariety = tropicalTraversal(startingCone);
   return toFanStar(tropicalVariety);

Singular/dyn_modules/gfanlib/witness.cc

@@ -17 +17 @@
 {
   ring origin = currRing;
-  rComplete(r);
   if (origin != r) rChangeCurrRing(r);
   ideal F = idInit(1); F->m[0]=f;
-  ideal m = idLift(G,F,NULL,FALSE,FALSE);
+  ideal m = idLift(G,F);
+  // ideal m = idLift(G,F,NULL,FALSE,TRUE);
   F->m[0]=NULL; id_Delete(&F, currRing);
   matrix Q = id_Module2formatedMatrix(m,IDELEMS(G),1,currRing);
@@ -53 +53 @@
 poly witness(const poly m, const ideal I, const ideal inI, const ring r)
 {
+  assume(idSize(I)==idSize(inI));
   matrix Q = divisionDiscardingRemainder(m,inI,r);