My Project  debian-1:4.1.1-p2+ds-4
Functions
tropicalCurves.h File Reference
#include "gfanlib/gfanlib_zcone.h"
#include "gfanlib/gfanlib_zfan.h"
#include "polys/monomials/p_polys.h"
#include "tropicalStrategy.h"
#include "tropicalVarietyOfPolynomials.h"

Go to the source code of this file.

Functions

ZConesSortedByDimension tropicalStar (const ideal I, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
 
gfan::ZMatrix raysOfTropicalStar (ideal I, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
 

Function Documentation

◆ raysOfTropicalStar()

gfan::ZMatrix raysOfTropicalStar ( ideal  I,
const ring  r,
const gfan::ZVector &  u,
const tropicalStrategy currentStrategy 
)

Definition at line 240 of file tropicalCurves.cc.

244 {
245  ZConesSortedByDimension C = tropicalStar(I,r,u,currentStrategy);
246  // gfan::ZFan* zf = toFanStar(C);
247  // std::cout << zf->toString();
248  // delete zf;
249  gfan::ZMatrix raysOfC(0,u.size());
250  if (!currentStrategy->restrictToLowerHalfSpace())
251  {
252  for (ZConesSortedByDimension::iterator zc=C.begin(); zc!=C.end(); zc++)
253  {
254  assume(zc->dimensionOfLinealitySpace()+1 >= zc->dimension());
255  if (zc->dimensionOfLinealitySpace()+1 >= zc->dimension())
256  raysOfC.appendRow(zc->getRelativeInteriorPoint());
257  else
258  {
259  gfan::ZVector interiorPoint = zc->getRelativeInteriorPoint();
260  if (!currentStrategy->homogeneitySpaceContains(interiorPoint))
261  {
262  raysOfC.appendRow(interiorPoint);
263  raysOfC.appendRow(currentStrategy->negateWeight(interiorPoint));
264  }
265  else
266  {
267  gfan::ZMatrix zm = zc->generatorsOfLinealitySpace();
268  for (int i=0; i<zm.getHeight(); i++)
269  {
270  gfan::ZVector point = zm[i];
271  if (currentStrategy->homogeneitySpaceContains(point))
272  {
273  raysOfC.appendRow(point);
274  raysOfC.appendRow(currentStrategy->negateWeight(point));
275  break;
276  }
277  }
278  }
279  }
280  }
281  }
282  else
283  {
284  for (ZConesSortedByDimension::iterator zc=C.begin(); zc!=C.end(); zc++)
285  {
286  assume(zc->dimensionOfLinealitySpace()+2 >= zc->dimension());
287  if (zc->dimensionOfLinealitySpace()+2 == zc->dimension())
288  raysOfC.appendRow(zc->getRelativeInteriorPoint());
289  else
290  {
291  gfan::ZVector interiorPoint = zc->getRelativeInteriorPoint();
292  if (!currentStrategy->homogeneitySpaceContains(interiorPoint))
293  {
294  raysOfC.appendRow(interiorPoint);
295  raysOfC.appendRow(currentStrategy->negateWeight(interiorPoint));
296  }
297  else
298  {
299  gfan::ZMatrix zm = zc->generatorsOfLinealitySpace();
300  for (int i=0; i<zm.getHeight(); i++)
301  {
302  gfan::ZVector point = zm[i];
303  if (currentStrategy->homogeneitySpaceContains(point))
304  {
305  raysOfC.appendRow(point);
306  raysOfC.appendRow(currentStrategy->negateWeight(point));
307  break;
308  }
309  }
310  }
311  }
312  }

◆ tropicalStar()

ZConesSortedByDimension tropicalStar ( const ideal  I,
const ring  r,
const gfan::ZVector &  u,
const tropicalStrategy currentStrategy 
)

Definition at line 104 of file tropicalCurves.cc.

109 {
110  int k = IDELEMS(inI);
111  int d = currentStrategy->getExpectedDimension();
112 
113  /* Compute the common refinement over all tropical varieties
114  * of the polynomials in the generating set */
115  ZConesSortedByDimension C = tropicalVarietySortedByDimension(inI->m[0],r,currentStrategy);
116  int PayneOsserman = rVar(r)-1;
117  for (int i=0; i<k; i++)
118  {
119  if(inI->m[i]!=NULL)
120  {
121  PayneOsserman--;
122  C = intersect(C,tropicalVarietySortedByDimension(inI->m[i],r,currentStrategy),si_max(PayneOsserman,d));
123  }
124  }
125 
126  /* Cycle through all maximal cones of the refinement.
127  * Pick a monomial ordering corresponding to a generic weight vector in it
128  * and check if the initial ideal is monomial free, generic meaning
129  * that it lies in a maximal Groebner cone in the maximal cone of the refinement.
130  * If the initial ideal is not monomial free, compute a witness for the monomial
131  * and compute the common refinement with its tropical variety.
132  * If all initial ideals are monomial free, then we have our tropical curve */
133  // gfan::ZFan* zf = toFanStar(C);
134  // std::cout << zf->toString(2+4+8+128) << std::endl;
135  // delete zf;
136  for (std::set<gfan::ZCone>::iterator zc=C.begin(); zc!=C.end();)
137  {
138  gfan::ZVector w = zc->getRelativeInteriorPoint();
139  gfan::ZMatrix W = zc->generatorsOfSpan();
140  // std::cout << zc->extremeRays() << std::endl;
141 
142  ring s = genericlyWeightedOrdering(r,u,w,W,currentStrategy);
143  nMapFunc identity = n_SetMap(r->cf,s->cf);
144  ideal inIs = idInit(k);
145  for (int j=0; j<k; j++)
146  inIs->m[j] = p_PermPoly(inI->m[j],NULL,r,s,identity,NULL,0);
147 
148  ideal inIsSTD = gfanlib_kStd_wrapper(inIs,s,isHomog);
149  id_Delete(&inIs,s);
150  ideal ininIs = initial(inIsSTD,s,w,W);
151 
152  std::pair<poly,int> mons = currentStrategy->checkInitialIdealForMonomial(ininIs,s);
153 
154  if (mons.first!=NULL)
155  {
156  poly gs;
157  if (mons.second>=0)
158  // cheap way out, ininIsSTD already contains a monomial in its generators
159  gs = inIsSTD->m[mons.second];
160  else
161  // compute witness
162  gs = witness(mons.first,inIsSTD,ininIs,s);
163 
164  C = intersect(C,tropicalVarietySortedByDimension(gs,s,currentStrategy),d);
165  nMapFunc mMap = n_SetMap(s->cf,r->cf);
166  poly gr = p_PermPoly(gs,NULL,s,r,mMap,NULL,0);
167  idInsertPoly(inI,gr);
168  k++;
169 
170  if (mons.second<0)
171  {
172  // if necessary, cleanup mons and gs
173  p_Delete(&mons.first,s);
174  p_Delete(&gs,s);
175  }
176  // cleanup rest, reset zc
177  id_Delete(&inIsSTD,s);
178  id_Delete(&ininIs,s);
179  rDelete(s);
180  zc = C.begin();
181  }
182  else
183  {
184  // cleanup remaining data of first stage
185  id_Delete(&inIsSTD,s);
186  id_Delete(&ininIs,s);
187  rDelete(s);
188 
189  gfan::ZVector wNeg = currentStrategy->negateWeight(w);
190  if (zc->contains(wNeg))
191  {
192  s = genericlyWeightedOrdering(r,u,wNeg,W,currentStrategy);
193  identity = n_SetMap(r->cf,s->cf);
194  inIs = idInit(k);
195  for (int j=0; j<k; j++)
196  inIs->m[j] = p_PermPoly(inI->m[j],NULL,r,s,identity,NULL,0);
197 
198  inIsSTD = gfanlib_kStd_wrapper(inIs,s,isHomog);
199  id_Delete(&inIs,s);
200  ininIs = initial(inIsSTD,s,wNeg,W);
201 
202  mons = currentStrategy->checkInitialIdealForMonomial(ininIs,s);
203  if (mons.first!=NULL)
204  {
205  poly gs;
206  if (mons.second>=0)
207  // cheap way out, ininIsSTD already contains a monomial in its generators
208  gs = inIsSTD->m[mons.second];
209  else
210  // compute witness
211  gs = witness(mons.first,inIsSTD,ininIs,s);
212 
213  C = intersect(C,tropicalVarietySortedByDimension(gs,s,currentStrategy),d);
214  nMapFunc mMap = n_SetMap(s->cf,r->cf);
215  poly gr = p_PermPoly(gs,NULL,s,r,mMap,NULL,0);
216  idInsertPoly(inI,gr);
217  k++;
218 
219  if (mons.second<0)
220  {
221  // if necessary, cleanup mons and gs
222  p_Delete(&mons.first,s);
223  p_Delete(&gs,s);
224  }
225  // reset zc
226  zc = C.begin();
227  }
228  else
229  zc++;
230  // cleanup remaining data of second stage
231  id_Delete(&inIsSTD,s);
232  id_Delete(&ininIs,s);
233  rDelete(s);
234  }
235  else
236  zc++;
237  }
tropicalStrategy::restrictToLowerHalfSpace
bool restrictToLowerHalfSpace() const
returns true, if valuation non-trivial, false otherwise
Definition: tropicalStrategy.h:238
j
int j
Definition: facHensel.cc:105
k
int k
Definition: cfEzgcd.cc:92
tropicalStar
ZConesSortedByDimension tropicalStar(ideal inI, const ring r, const gfan::ZVector &u, const tropicalStrategy *currentStrategy)
Definition: tropicalCurves.cc:104
intersect
static ZConesSortedByDimension intersect(const ZConesSortedByDimension &setA, const ZConesSortedByDimension &setB, int d=0)
Definition: tropicalCurves.cc:17
tropicalStrategy::negateWeight
gfan::ZVector negateWeight(const gfan::ZVector &w) const
Definition: tropicalStrategy.h:263
idInsertPoly
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
Definition: simpleideals.cc:639
tropicalStrategy::getExpectedDimension
int getExpectedDimension() const
returns the expected Dimension of the polyhedral output
Definition: tropicalStrategy.h:199
initial
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:30
tropicalStrategy::checkInitialIdealForMonomial
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...
Definition: tropicalStrategy.cc:492
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
tropicalStrategy::homogeneitySpaceContains
bool homogeneitySpaceContains(const gfan::ZVector &v) const
returns true, if v is contained in the homogeneity space; false otherwise
Definition: tropicalStrategy.h:230
rVar
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:582
i
int i
Definition: cfEzgcd.cc:125
id_Delete
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
Definition: simpleideals.cc:113
p_PermPoly
poly p_PermPoly(poly p, const int *perm, const ring oldRing, const ring dst, nMapFunc nMap, const int *par_perm, int OldPar, BOOLEAN use_mult)
Definition: p_polys.cc:4011
nMapFunc
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
ZConesSortedByDimension
std::set< gfan::ZCone, ZConeCompareDimensionFirst > ZConesSortedByDimension
Definition: tropicalVarietyOfPolynomials.h:27
tropicalVarietySortedByDimension
ZConesSortedByDimension tropicalVarietySortedByDimension(const poly g, const ring r, const tropicalStrategy *currentCase)
Definition: tropicalVarietyOfPolynomials.cc:61
isHomog
Definition: structs.h:39
gfanlib_kStd_wrapper
ideal gfanlib_kStd_wrapper(ideal I, ring r, tHomog h=testHomog)
Definition: std_wrapper.cc:6
rDelete
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:438
p_Delete
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:842
si_max
static int si_max(const int a, const int b)
Definition: auxiliary.h:138
idInit
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:36
genericlyWeightedOrdering
static ring genericlyWeightedOrdering(const ring r, const gfan::ZVector &u, const gfan::ZVector &w, const gfan::ZMatrix &W, const tropicalStrategy *currentStrategy)
Definition: tropicalCurves.cc:47
assume
#define assume(x)
Definition: mod2.h:384
NULL
#define NULL
Definition: omList.c:9
witness
poly witness(const poly m, const ideal I, const ideal inI, const ring r)
Let w be the uppermost weight vector in the matrix defining the ordering on r.
Definition: witness.cc:34
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
n_SetMap
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:721
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24