Public Member Functions | Private Attributes | Friends
groebnerCone Class Reference

#include <groebnerCone.h>

Public Member Functions

 groebnerCone ()
 
 groebnerCone (const ideal I, const ring r, const tropicalStrategy &currentCase)
 
 groebnerCone (const ideal I, const ring r, const gfan::ZVector &w, const tropicalStrategy &currentCase)
 
 groebnerCone (const ideal I, const ring r, const gfan::ZVector &u, const gfan::ZVector &w, const tropicalStrategy &currentCase)
 
 groebnerCone (const ideal I, const ideal inI, const ring r, const tropicalStrategy &currentCase)
 
 groebnerCone (const groebnerCone &sigma)
 
 ~groebnerCone ()
 
groebnerConeoperator= (const groebnerCone &sigma)
 
void deletePolynomialData ()
 
ideal getPolynomialIdeal () const
 
ring getPolynomialRing () const
 
gfan::ZCone getPolyhedralCone () const
 
gfan::ZVector getInteriorPoint () const
 
const tropicalStrategygetTropicalStrategy () const
 
bool isTrivial () const
 
bool contains (const gfan::ZVector &w) const
 Returns true if Groebner cone contains w, false otherwise. More...
 
gfan::ZVector tropicalPoint () const
 Returns a point in the tropical variety, if the groebnerCone contains one. More...
 
groebnerCone flipCone (const gfan::ZVector &interiorPoint, const gfan::ZVector &facetNormal) const
 Given an interior point on the facet and the outer normal factor on the facet, returns the adjacent groebnerCone sharing that facet. More...
 
groebnerCones groebnerNeighbours () const
 Returns a complete list of neighboring Groebner cones. More...
 
groebnerCones tropicalNeighbours () const
 Returns a complete list of neighboring Groebner cones in the tropical variety. More...
 
bool checkFlipConeInput (const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal) const
 Debug tools. More...
 
bool pointsOutwards (const gfan::ZVector) const
 

Private Attributes

ideal polynomialIdeal
 ideal to which this Groebner cone belongs to More...
 
ring polynomialRing
 ring in which the ideal exists More...
 
gfan::ZCone polyhedralCone
 
gfan::ZVector interiorPoint
 
const tropicalStrategycurrentStrategy
 

Friends

struct groebnerCone_compare
 

Detailed Description

Definition at line 28 of file groebnerCone.h.

Constructor & Destructor Documentation

groebnerCone::groebnerCone ( )

Definition at line 115 of file groebnerCone.cc.

115  :
118  polyhedralCone(gfan::ZCone(0)),
119  interiorPoint(gfan::ZVector(0)),
121 {
122 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
#define NULL
Definition: omList.c:10
groebnerCone::groebnerCone ( const ideal  I,
const ring  r,
const tropicalStrategy currentCase 
)

Definition at line 124 of file groebnerCone.cc.

124  :
127  currentStrategy(&currentCase)
128 {
130  if (r) polynomialRing = rCopy(r);
131  if (I)
132  {
136  }
137 
138  int n = rVar(polynomialRing);
139  poly g = NULL;
140  int* leadexpv = (int*) omAlloc((n+1)*sizeof(int));
141  int* tailexpv = (int*) omAlloc((n+1)*sizeof(int));
142  gfan::ZVector leadexpw = gfan::ZVector(n);
143  gfan::ZVector tailexpw = gfan::ZVector(n);
144  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
145  for (int i=0; i<idSize(polynomialIdeal); i++)
146  {
147  g = polynomialIdeal->m[i];
148  if (g)
149  {
150  p_GetExpV(g,leadexpv,r);
151  leadexpw = expvToZVector(n, leadexpv);
152  pIter(g);
153  while (g)
154  {
155  p_GetExpV(g,tailexpv,r);
156  tailexpw = expvToZVector(n, tailexpv);
157  inequalities.appendRow(leadexpw-tailexpw);
158  pIter(g);
159  }
160  }
161  }
162  omFreeSize(leadexpv,(n+1)*sizeof(int));
163  omFreeSize(tailexpv,(n+1)*sizeof(int));
164  // if (currentStrategy->restrictToLowerHalfSpace())
165  // {
166  // gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
167  // lowerHalfSpaceCondition[0] = -1;
168  // inequalities.appendRow(lowerHalfSpaceCondition);
169  // }
170 
171  polyhedralCone = gfan::ZCone(inequalities,gfan::ZMatrix(0, inequalities.getWidth()));
172  polyhedralCone.canonicalize();
173  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
175 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1448
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
void pReduce(ideal I, const ring r) const
bool reduce(ideal I, const ring r) const
reduces the generators of an ideal I so that the inequalities and equations of the Groebner cone can ...
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
g
Definition: cfModGcd.cc:4031
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define pIter(p)
Definition: monomials.h:44
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:527
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
int i
Definition: cfEzgcd.cc:123
gfan::ZVector expvToZVector(const int n, const int *expv)
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
ring rCopy(ring r)
Definition: ring.cc:1618
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
#define NULL
Definition: omList.c:10
static int idSize(const ideal id)
Count the effective size of an ideal (without the trailing allocated zero-elements) ...
Definition: ideals.h:46
polyrec * poly
Definition: hilb.h:10
groebnerCone::groebnerCone ( const ideal  I,
const ring  r,
const gfan::ZVector &  w,
const tropicalStrategy currentCase 
)

Definition at line 177 of file groebnerCone.cc.

177  :
180  currentStrategy(&currentCase)
181 {
183  if (r) polynomialRing = rCopy(r);
184  if (I)
185  {
189  }
190 
191  int n = rVar(polynomialRing);
192  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
193  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
194  int* expv = (int*) omAlloc((n+1)*sizeof(int));
195  for (int i=0; i<idSize(polynomialIdeal); i++)
196  {
197  poly g = polynomialIdeal->m[i];
198  if (g)
199  {
200  p_GetExpV(g,expv,polynomialRing);
201  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
202  long d = wDeg(g,polynomialRing,w);
203  for (pIter(g); g; pIter(g))
204  {
205  p_GetExpV(g,expv,polynomialRing);
206  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
207  if (wDeg(g,polynomialRing,w)==d)
208  equations.appendRow(leadexpv-tailexpv);
209  else
210  {
211  assume(wDeg(g,polynomialRing,w)<d);
212  inequalities.appendRow(leadexpv-tailexpv);
213  }
214  }
215  }
216  }
217  omFreeSize(expv,(n+1)*sizeof(int));
218  // if (currentStrategy->restrictToLowerHalfSpace())
219  // {
220  // gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
221  // lowerHalfSpaceCondition[0] = -1;
222  // inequalities.appendRow(lowerHalfSpaceCondition);
223  // }
224 
225  polyhedralCone = gfan::ZCone(inequalities,equations);
226  polyhedralCone.canonicalize();
227  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
229 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal id_Copy(ideal h1, const ring r)
copy an ideal
long wDeg(const poly p, const ring r, const gfan::ZVector w)
various functions to compute the initial form of polynomials and ideals
Definition: initial.cc:8
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1448
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
void pReduce(ideal I, const ring r) const
bool reduce(ideal I, const ring r) const
reduces the generators of an ideal I so that the inequalities and equations of the Groebner cone can ...
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
g
Definition: cfModGcd.cc:4031
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define pIter(p)
Definition: monomials.h:44
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:527
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
gfan::ZVector intStar2ZVector(const int d, const int *i)
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
int i
Definition: cfEzgcd.cc:123
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
ring rCopy(ring r)
Definition: ring.cc:1618
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
#define NULL
Definition: omList.c:10
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:543
const CanonicalForm & w
Definition: facAbsFact.cc:55
static int idSize(const ideal id)
Count the effective size of an ideal (without the trailing allocated zero-elements) ...
Definition: ideals.h:46
polyrec * poly
Definition: hilb.h:10
groebnerCone::groebnerCone ( const ideal  I,
const ring  r,
const gfan::ZVector &  u,
const gfan::ZVector &  w,
const tropicalStrategy currentCase 
)

Definition at line 235 of file groebnerCone.cc.

235  :
238  currentStrategy(&currentCase)
239 {
241  if (r) polynomialRing = rCopy(r);
242  if (I)
243  {
247  }
248 
249  int n = rVar(polynomialRing);
250  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
251  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
252  int* expv = (int*) omAlloc((n+1)*sizeof(int));
253  for (int i=0; i<idSize(polynomialIdeal); i++)
254  {
255  poly g = polynomialIdeal->m[i];
256  if (g)
257  {
258  p_GetExpV(g,expv,polynomialRing);
259  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
260  long d1 = wDeg(g,polynomialRing,u);
261  long d2 = wDeg(g,polynomialRing,w);
262  for (pIter(g); g; pIter(g))
263  {
264  p_GetExpV(g,expv,polynomialRing);
265  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
266  if (wDeg(g,polynomialRing,u)==d1 && wDeg(g,polynomialRing,w)==d2)
267  equations.appendRow(leadexpv-tailexpv);
268  else
269  {
270  assume(wDeg(g,polynomialRing,u)<d1 || wDeg(g,polynomialRing,w)<d2);
271  inequalities.appendRow(leadexpv-tailexpv);
272  }
273  }
274  }
275  }
276  omFreeSize(expv,(n+1)*sizeof(int));
277  // if (currentStrategy->restrictToLowerHalfSpace())
278  // {
279  // gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
280  // lowerHalfSpaceCondition[0] = -1;
281  // inequalities.appendRow(lowerHalfSpaceCondition);
282  // }
283 
284  polyhedralCone = gfan::ZCone(inequalities,equations);
285  polyhedralCone.canonicalize();
286  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
288 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal id_Copy(ideal h1, const ring r)
copy an ideal
long wDeg(const poly p, const ring r, const gfan::ZVector w)
various functions to compute the initial form of polynomials and ideals
Definition: initial.cc:8
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1448
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
void pReduce(ideal I, const ring r) const
bool reduce(ideal I, const ring r) const
reduces the generators of an ideal I so that the inequalities and equations of the Groebner cone can ...
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
g
Definition: cfModGcd.cc:4031
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define pIter(p)
Definition: monomials.h:44
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:527
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
gfan::ZVector intStar2ZVector(const int d, const int *i)
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
int i
Definition: cfEzgcd.cc:123
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
ring rCopy(ring r)
Definition: ring.cc:1618
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
#define NULL
Definition: omList.c:10
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:543
const CanonicalForm & w
Definition: facAbsFact.cc:55
static int idSize(const ideal id)
Count the effective size of an ideal (without the trailing allocated zero-elements) ...
Definition: ideals.h:46
polyrec * poly
Definition: hilb.h:10
groebnerCone::groebnerCone ( const ideal  I,
const ideal  inI,
const ring  r,
const tropicalStrategy currentCase 
)

Definition at line 291 of file groebnerCone.cc.

291  :
294  currentStrategy(&currentCase)
295 {
298 
301 
302  int n = rVar(r);
303  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
304  int* expv = (int*) omAlloc((n+1)*sizeof(int));
305  for (int i=0; i<idSize(inI); i++)
306  {
307  poly g = inI->m[i];
308  if (g)
309  {
310  p_GetExpV(g,expv,r);
311  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
312  for (pIter(g); g; pIter(g))
313  {
314  p_GetExpV(g,expv,r);
315  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
316  equations.appendRow(leadexpv-tailexpv);
317  }
318  }
319  }
320  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
321  for (int i=0; i<idSize(polynomialIdeal); i++)
322  {
323  poly g = polynomialIdeal->m[i];
324  if (g)
325  {
326  p_GetExpV(g,expv,r);
327  gfan::ZVector leadexpv = intStar2ZVector(n,expv);
328  for (pIter(g); g; pIter(g))
329  {
330  p_GetExpV(g,expv,r);
331  gfan::ZVector tailexpv = intStar2ZVector(n,expv);
332  inequalities.appendRow(leadexpv-tailexpv);
333  }
334  }
335  }
336  omFreeSize(expv,(n+1)*sizeof(int));
338  {
339  gfan::ZVector lowerHalfSpaceCondition = gfan::ZVector(n);
340  lowerHalfSpaceCondition[0] = -1;
341  inequalities.appendRow(lowerHalfSpaceCondition);
342  }
343 
344  polyhedralCone = gfan::ZCone(inequalities,equations);
345  polyhedralCone.canonicalize();
346  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
348 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1448
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:540
void pReduce(ideal I, const ring r) const
bool reduce(ideal I, const ring r) const
reduces the generators of an ideal I so that the inequalities and equations of the Groebner cone can ...
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
g
Definition: cfModGcd.cc:4031
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define pIter(p)
Definition: monomials.h:44
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
BOOLEAN inequalities(leftv res, leftv args)
Definition: bbcone.cc:527
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
gfan::ZVector intStar2ZVector(const int d, const int *i)
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
int i
Definition: cfEzgcd.cc:123
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
ring rCopy(ring r)
Definition: ring.cc:1618
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
BOOLEAN equations(leftv res, leftv args)
Definition: bbcone.cc:543
static int idSize(const ideal id)
Count the effective size of an ideal (without the trailing allocated zero-elements) ...
Definition: ideals.h:46
polyrec * poly
Definition: hilb.h:10
groebnerCone::groebnerCone ( const groebnerCone sigma)

Definition at line 350 of file groebnerCone.cc.

350  :
353  polyhedralCone(gfan::ZCone(sigma.getPolyhedralCone())),
354  interiorPoint(gfan::ZVector(sigma.getInteriorPoint())),
356 {
362 }
gfan::ZVector getInteriorPoint() const
Definition: groebnerCone.h:66
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
const tropicalStrategy * getTropicalStrategy() const
Definition: groebnerCone.h:67
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal id_Copy(ideal h1, const ring r)
copy an ideal
gfan::ZCone getPolyhedralCone() const
Definition: groebnerCone.h:65
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
static bool checkPolyhedralInput(const gfan::ZCone zc, const gfan::ZVector p)
Definition: groebnerCone.cc:55
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
#define assume(x)
Definition: mod2.h:405
ideal getPolynomialIdeal() const
Definition: groebnerCone.h:63
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
ring rCopy(ring r)
Definition: ring.cc:1618
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
#define NULL
Definition: omList.c:10
ring getPolynomialRing() const
Definition: groebnerCone.h:64
groebnerCone::~groebnerCone ( )

Definition at line 364 of file groebnerCone.cc.

365 {
371 }
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
static bool checkPolyhedralInput(const gfan::ZCone zc, const gfan::ZVector p)
Definition: groebnerCone.cc:55
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
#define assume(x)
Definition: mod2.h:405
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:448

Member Function Documentation

bool groebnerCone::checkFlipConeInput ( const gfan::ZVector  interiorPoint,
const gfan::ZVector  facetNormal 
) const

Debug tools.

Definition at line 69 of file groebnerCone.cc.

70 {
71  /* check first whether interiorPoint lies on the boundary of the cone */
72  if (!polyhedralCone.contains(interiorPoint))
73  {
74  std::cout << "ERROR: interiorPoint is not contained in the Groebner cone!" << std::endl
75  << "cone: " << std::endl
77  << "interiorPoint:" << std::endl
78  << interiorPoint << std::endl;
79  return false;
80  }
81  if (polyhedralCone.containsRelatively(interiorPoint))
82  {
83  std::cout << "ERROR: interiorPoint is contained in the interior of the maximal Groebner cone!" << std::endl
84  << "cone: " << std::endl
86  << "interiorPoint:" << std::endl
87  << interiorPoint << std::endl;
88  return false;
89  }
90  gfan::ZCone hopefullyAFacet = polyhedralCone.faceContaining(interiorPoint);
91  if (hopefullyAFacet.dimension()!=(polyhedralCone.dimension()-1))
92  {
93  std::cout << "ERROR: interiorPoint is not contained in the interior of a facet!" << std::endl
94  << "cone: " << std::endl
96  << "interiorPoint:" << std::endl
97  << interiorPoint << std::endl;
98  return false;
99  }
100  /* check whether facet normal points outwards */
101  gfan::ZCone dual = polyhedralCone.dualCone();
102  if(dual.containsRelatively(facetNormal))
103  {
104  std::cout << "ERROR: facetNormal is not pointing outwards!" << std::endl
105  << "cone: " << std::endl
107  << "facetNormal:" << std::endl
108  << facetNormal << std::endl;
109  return false;
110  }
111  return true;
112 }
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
std::string toString(const gfan::ZCone *const c)
Definition: bbcone.cc:26
bool groebnerCone::contains ( const gfan::ZVector &  w) const

Returns true if Groebner cone contains w, false otherwise.

Definition at line 389 of file groebnerCone.cc.

390 {
391  return polyhedralCone.contains(w);
392 }
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
const CanonicalForm & w
Definition: facAbsFact.cc:55
void groebnerCone::deletePolynomialData ( )
inline

Definition at line 54 of file groebnerCone.h.

55  {
61  }
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
#define assume(x)
Definition: mod2.h:405
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
#define NULL
Definition: omList.c:10
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:448
groebnerCone groebnerCone::flipCone ( const gfan::ZVector &  interiorPoint,
const gfan::ZVector &  facetNormal 
) const

Given an interior point on the facet and the outer normal factor on the facet, returns the adjacent groebnerCone sharing that facet.

Definition at line 428 of file groebnerCone.cc.

429 {
430  assume(this->checkFlipConeInput(interiorPoint,facetNormal));
431  /* Note: the polynomial ring created will have a weighted ordering with respect to interiorPoint
432  * and with a weighted ordering with respect to facetNormal as tiebreaker.
433  * Hence it is sufficient to compute the initial form with respect to facetNormal,
434  * to obtain an initial form with respect to interiorPoint+e*facetNormal,
435  * for e>0 sufficiently small */
436  std::pair<ideal,ring> flipped = currentStrategy->computeFlip(polynomialIdeal,polynomialRing,interiorPoint,facetNormal);
437  assume(checkPolynomialInput(flipped.first,flipped.second));
438  groebnerCone flippedCone(flipped.first, flipped.second, interiorPoint, facetNormal, *currentStrategy);
439  id_Delete(&flipped.first,flipped.second);
440  rDelete(flipped.second);
441  return flippedCone;
442 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
bool checkFlipConeInput(const gfan::ZVector interiorPoint, const gfan::ZVector facetNormal) const
Debug tools.
Definition: groebnerCone.cc:69
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
#define assume(x)
Definition: mod2.h:405
std::pair< ideal, ring > computeFlip(const ideal Ir, const ring r, const gfan::ZVector &interiorPoint, const gfan::ZVector &facetNormal) const
given an interior point of a groebner cone computes the groebner cone adjacent to it ...
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:448
gfan::ZVector groebnerCone::getInteriorPoint ( ) const
inline

Definition at line 66 of file groebnerCone.h.

66 { return interiorPoint; };
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
gfan::ZCone groebnerCone::getPolyhedralCone ( ) const
inline

Definition at line 65 of file groebnerCone.h.

65 { return polyhedralCone; };
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal groebnerCone::getPolynomialIdeal ( ) const
inline

Definition at line 63 of file groebnerCone.h.

63 { return polynomialIdeal; };
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
ring groebnerCone::getPolynomialRing ( ) const
inline

Definition at line 64 of file groebnerCone.h.

64 { return polynomialRing; };
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
const tropicalStrategy* groebnerCone::getTropicalStrategy ( ) const
inline

Definition at line 67 of file groebnerCone.h.

67 { return currentStrategy; };
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
groebnerCones groebnerCone::groebnerNeighbours ( ) const

Returns a complete list of neighboring Groebner cones.

Definition at line 448 of file groebnerCone.cc.

449 {
450  std::pair<gfan::ZMatrix, gfan::ZMatrix> facetsData = interiorPointsAndNormalsOfFacets(polyhedralCone);
451 
452  gfan::ZMatrix interiorPoints = facetsData.first;
453  gfan::ZMatrix facetNormals = facetsData.second;
454 
455  groebnerCones neighbours;
456  for (int i=0; i<interiorPoints.getHeight(); i++)
457  {
458  gfan::ZVector w = interiorPoints[i];
459  gfan::ZVector v = facetNormals[i];
461  {
462  assume(w[0].sign()<=0);
463  if (w[0].sign()==0 && v[0].sign()>0)
464  continue;
465  }
466  neighbours.insert(flipCone(interiorPoints[i],facetNormals[i]));
467  }
468  return neighbours;
469 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
groebnerCone flipCone(const gfan::ZVector &interiorPoint, const gfan::ZVector &facetNormal) const
Given an interior point on the facet and the outer normal factor on the facet, returns the adjacent g...
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
std::pair< gfan::ZMatrix, gfan::ZMatrix > interiorPointsAndNormalsOfFacets(const gfan::ZCone zc, const std::set< gfan::ZVector > &exceptThesePoints, const bool onlyLowerHalfSpace)
Definition: bbcone.cc:1674
std::set< groebnerCone, groebnerCone_compare > groebnerCones
Definition: groebnerCone.h:24
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
const CanonicalForm & w
Definition: facAbsFact.cc:55
int sign(const CanonicalForm &a)
bool groebnerCone::isTrivial ( ) const
inline

Definition at line 70 of file groebnerCone.h.

71  {
72  bool b = (polynomialRing==NULL);
73  return b;
74  }
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
groebnerCone & groebnerCone::operator= ( const groebnerCone sigma)

Definition at line 373 of file groebnerCone.cc.

374 {
383  return *this;
384 }
gfan::ZVector getInteriorPoint() const
Definition: groebnerCone.h:66
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
const tropicalStrategy * getTropicalStrategy() const
Definition: groebnerCone.h:67
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal id_Copy(ideal h1, const ring r)
copy an ideal
gfan::ZCone getPolyhedralCone() const
Definition: groebnerCone.h:65
static bool checkPolynomialInput(const ideal I, const ring r)
Definition: groebnerCone.cc:25
static bool checkPolyhedralInput(const gfan::ZCone zc, const gfan::ZVector p)
Definition: groebnerCone.cc:55
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
#define assume(x)
Definition: mod2.h:405
ideal getPolynomialIdeal() const
Definition: groebnerCone.h:63
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
gfan::ZVector interiorPoint
Definition: groebnerCone.h:41
ring rCopy(ring r)
Definition: ring.cc:1618
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
ring getPolynomialRing() const
Definition: groebnerCone.h:64
bool groebnerCone::pointsOutwards ( const gfan::ZVector  w) const

Definition at line 472 of file groebnerCone.cc.

473 {
474  gfan::ZCone dual = polyhedralCone.dualCone();
475  return (!dual.contains(w));
476 }
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
const CanonicalForm & w
Definition: facAbsFact.cc:55
groebnerCones groebnerCone::tropicalNeighbours ( ) const

Returns a complete list of neighboring Groebner cones in the tropical variety.

Definition at line 482 of file groebnerCone.cc.

483 {
484  gfan::ZMatrix interiorPoints = interiorPointsOfFacets(polyhedralCone);
485  groebnerCones neighbours;
486  for (int i=0; i<interiorPoints.getHeight(); i++)
487  {
488  if (!(currentStrategy->restrictToLowerHalfSpace() && interiorPoints[i][0].sign()==0))
489  {
490  ideal initialIdeal = initial(polynomialIdeal,polynomialRing,interiorPoints[i]);
491  gfan::ZMatrix ray = raysOfTropicalStar(initialIdeal,polynomialRing,interiorPoints[i],currentStrategy);
492  for (int j=0; j<ray.getHeight(); j++)
493  if (pointsOutwards(ray[j]))
494  {
495  groebnerCone neighbour = flipCone(interiorPoints[i],ray[j]);
496  neighbours.insert(neighbour);
497  }
498  id_Delete(&initialIdeal,polynomialRing);
499  }
500  }
501  return neighbours;
502 }
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
groebnerCone flipCone(const gfan::ZVector &interiorPoint, const gfan::ZVector &facetNormal) const
Given an interior point on the facet and the outer normal factor on the facet, returns the adjacent g...
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
std::set< groebnerCone, groebnerCone_compare > groebnerCones
Definition: groebnerCone.h:24
poly initial(const poly p, const ring r, const gfan::ZVector w)
Returns the initial form of p with respect to w.
Definition: initial.cc:32
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
int j
Definition: myNF.cc:70
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
bool pointsOutwards(const gfan::ZVector) const
int i
Definition: cfEzgcd.cc:123
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
gfan::ZMatrix raysOfTropicalStar(ideal I, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
gfan::ZMatrix interiorPointsOfFacets(const gfan::ZCone &zc, const std::set< gfan::ZVector > &exceptThese)
Definition: bbcone.cc:1620
gfan::ZVector groebnerCone::tropicalPoint ( ) const

Returns a point in the tropical variety, if the groebnerCone contains one.

Returns an empty vector otherwise.

Definition at line 399 of file groebnerCone.cc.

400 {
402  ideal I = polynomialIdeal;
403  ring r = polynomialRing;
404 
405  gfan::ZCone coneToCheck = polyhedralCone;
406  gfan::ZMatrix R = coneToCheck.extremeRays();
407  for (int i=0; i<R.getHeight(); i++)
408  {
409  assume(!currentStrategy->restrictToLowerHalfSpace() || R[i][0].sign()<=0);
410  if (currentStrategy->restrictToLowerHalfSpace() && R[i][0].sign()==0)
411  continue;
412  std::pair<poly,int> s = currentStrategy->checkInitialIdealForMonomial(I,r,R[i]);
413  if (s.first==NULL)
414  {
415  if (s.second<0)
416  // if monomial was initialized, delete it
417  p_Delete(&s.first,r);
418  return R[i];
419  }
420  }
421  return gfan::ZVector();
422 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
const tropicalStrategy * currentStrategy
Definition: groebnerCone.h:42
gfan::ZCone polyhedralCone
Definition: groebnerCone.h:40
ideal polynomialIdeal
ideal to which this Groebner cone belongs to
Definition: groebnerCone.h:35
const ring r
Definition: syzextra.cc:208
#define assume(x)
Definition: mod2.h:405
ring polynomialRing
ring in which the ideal exists
Definition: groebnerCone.h:39
int i
Definition: cfEzgcd.cc:123
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:850
static bool checkOrderingAndCone(const ring r, const gfan::ZCone zc)
Definition: groebnerCone.cc:32
#define NULL
Definition: omList.c:10
#define R
Definition: sirandom.c:26
std::pair< poly, int > checkInitialIdealForMonomial(const ideal I, const ring r, const gfan::ZVector &w=0) const
If given w, assuming w is in the Groebner cone of the ordering on r and I is a standard basis with re...

Friends And Related Function Documentation

friend struct groebnerCone_compare
friend

Definition at line 67 of file groebnerCone.h.

Field Documentation

const tropicalStrategy* groebnerCone::currentStrategy
private

Definition at line 42 of file groebnerCone.h.

gfan::ZVector groebnerCone::interiorPoint
private

Definition at line 41 of file groebnerCone.h.

gfan::ZCone groebnerCone::polyhedralCone
private

Definition at line 40 of file groebnerCone.h.

ideal groebnerCone::polynomialIdeal
private

ideal to which this Groebner cone belongs to

Definition at line 35 of file groebnerCone.h.

ring groebnerCone::polynomialRing
private

ring in which the ideal exists

Definition at line 39 of file groebnerCone.h.


The documentation for this class was generated from the following files: