source: git/Singular/LIB/realizationMatroids.lib @ b0732eb

jengelh-datetimespielwiese
Last change on this file since b0732eb was b0732eb, checked in by Hans Schoenemann <hannes@…>, 11 years ago
add: new libs from master
  • Property mode set to 100644
File size: 20.1 KB
Line 
1/////////////////////////////////////////////////////////////////////////////
2version="$Id$";
3category="Tropical Geometry";
4info="
5LIBRARY:  realizationMatroids.lib   Deciding Relative Realizability for Tropical Fan Curves in 2-Dimensional Matroidal Fans
6AUTHORS:  Anna Lena Winstel, winstel@mathematik.uni-kl.de
7OVERVIEW: In tropical geometry, one question to ask is the following: given a one-dimensional balanced polyhedral fan C which is set theoretically contained in the tropicalization trop(Y) of an algebraic variety Y, does there exist a curve X in Y such that trop(X) = C? This equality of C and trop(X) denotes an equality of both, the fans trop(X) and C and their weights on the maximal cones. The relative realization space of C with respect to Y is the space of all algebraic curves in Y which tropicalize to C.
8
9This library provides procedures deciding relative realizability for tropical fan curves, i.e. one-dimensional weighted balanced polyhedral fans, contained in two-dimensional matroidal fans trop(Y) where Y is a projective plane.
10
11NOTATION: If Y is a projective plane in (n-1)-dimensional projective space, we consider trop(Y) in R^n/<1>. Moreover, for the relative realization space of C with respect to Y we only consider algebraic curves of degree deg(C) in Y which tropicalize to C.
12
13PROCEDURES:
14
15realizationDim(I,C);          For a given tropical fan curve C in trop(Y), where Y = V(I) is a projective plane, this routine returns the dimension of the relative realization space of C with respect to Y, that is the space of all algebraic curves of degree deg(C) in Y which tropicalize to C. If the realization space is empty, the output is set to -1.
16
17irrRealizationDim(I,C);       This routine returns the dimension of the irreducible relative realization space of the tropical fan curve C with respect to Y = V(I), that is the space of all irreducible algebraic curves of degree deg(C) in Y which tropicalize to C. If the irreducible relative realization space is empty, the output is set to -1.
18
19realizationDimPoly(I,C);      If C is a tropical fan curve contained in the tropicalization trop(Y) of the projective plane Y = V(I) such that the relative realization space M of C is non-empty, this routine returns the tuple (dim(M),f) where f is an example of a homogeneous polynomial of degree deg(C) cutting out a curve X in Y which tropicalizes to C. If M is empty, the output is set to -1.
20
21";
22
23LIB "control.lib";
24LIB "qhmoduli.lib";
25
26static proc gcdvector(intvec v)
27{
28  int i;
29  int ggt = 0;
30  for(i=1;i<=size(v);i++)
31  {
32    ggt = gcd(ggt,v[i]);
33    if( ggt == 1 )
34    {
35      return(ggt);
36    }
37  }
38  return(ggt);
39}
40
41static proc balanced(list lInput)
42{
43  list ba;
44  int i;
45  int j;
46  if(size(lInput)>0)
47  {
48    for(i=1;i<=size(lInput[1]);i++)
49    {
50      ba[i] = 0;
51      for(j=1;j<=size(lInput);j++)
52      {
53        ba[i] = ba[i] + lInput[j][i];
54      }
55    }
56    int boolean = 1;
57    for(i=2;i<=size(ba);i++)
58    {
59      if(ba[i] != ba[1])
60      {
61        boolean = 0;
62      }
63    }
64    if(boolean == 1)
65    {
66      return(ba[1]);
67    }
68    else
69    {
70      return(0);
71    }
72  }
73  else
74  {
75    return(0);
76  }
77}
78
79static proc genPoly(int d, int i, int j, int k)
80{
81  int ii;
82  int ij;
83  int ik = 1;
84  poly f = 0;
85  for(ii=0;ii<=d;ii++)
86  {
87    for(ij=0;ij<=d-ii;ij++)
88    {
89       f = f + a(ik)*x(i)^(d-ii-ij)*x(j)^ij*x(k)^ii;
90       ik = ik + 1;
91    }
92  }
93  return(f);
94}
95
96static proc prodvar(int n)
97{
98  int i;
99  poly f = 1;
100  for(i=1;i<=n;i++)
101  {
102    f = f * x(i);
103  }
104  return(f);
105}
106
107static proc lessThan(int i, int j, intvec v, intvec w)
108{
109  number a = v[i];
110  number b = v[j];
111  number c = w[i];
112  number d = w[j];
113  if((a/b)<(c/d))
114  { return(1); }
115  else
116  { return(0); }
117}
118
119static proc sortSlope(int i, int j, list lInput)
120{
121  int k;
122  int l;
123  intvec v;
124  for(k=1;k<size(lInput);k++)
125  {
126    for(l=1;l<=size(lInput)-k;l++)
127    {
128      if(lessThan(i,j,lInput[l+1],lInput[l]))
129      {
130        v = lInput[l];
131        lInput[l] = lInput[l+1];
132        lInput[l+1] = v;
133      }
134    }
135  }
136  return(lInput);
137}
138
139static proc coefMonomial(poly f, poly g, int n)
140{
141  matrix m = coef(f,prodvar(n));
142  poly h;
143  for(int i=1;i<=ncols(m);i++)
144  {
145    if(m[1,i] == g)
146    {
147      h = m[2,i];
148    }
149  }
150  return(h);
151}
152
153static proc ismultiple(intvec v, intvec w)
154{
155  int boolean = 1;
156  if(v[1] != 0)
157  {
158    if((number(w[2]) == number(v[2])*number(w[1])/number(v[1])) and (number(w[3]) == number(v[3])*number(w[1])/number(v[1])))
159    {
160      return(1);
161    }
162    else
163    {
164      return(0);
165    }
166  }
167  else
168  {
169    if(v[2] != 0)
170    {
171      if((number(w[1]) == number(v[1])*number(w[2])/number(v[2])) and (number(w[3]) == number(v[3])*number(w[2])/number(v[2])))
172      {
173        return(1);
174      }
175      else
176      {
177        return(0);
178      }
179    }
180    else
181    {
182      if((w[2] == 0) and (w[1] == 0))
183      {
184        return(1);
185      }
186      else
187      {
188        return(0);
189      }
190    }
191  }
192}
193
194static proc simplifyList(list lInput);
195{
196  int i;
197  int k = size(lInput);
198  for(i=1;i<=k;i++)
199  {
200    if(lInput[i] == intvec(0,0,0))
201    {
202      lInput = delete(lInput,i);
203      k = k-1;
204      i = i-1;
205    }
206  }
207  k = size(lInput);
208  int j;
209  for(i=1;i<k;i++)
210  {
211    for(j=i+1;j<=k;j++)
212    {
213      if(ismultiple(lInput[i],lInput[j]))
214      {
215        lInput[i] = lInput[i] + lInput[j];
216        lInput = delete(lInput,j);
217        j = j-1;
218        k = k-1;
219      }
220    }
221  }
222  return(lInput);
223}
224
225static proc realizationDimIdeal(ideal iInput, list lInput)
226{
227  //normalize the vectors
228  intvec helpintvec = 1;
229  int i;
230  int c;
231  for(i=1;i<size(lInput[1]);i++)
232  {
233    helpintvec = helpintvec,1;
234  }
235  for(i=1;i<=size(lInput);i++)
236  {
237    lInput[i] = lInput[i] - Min(lInput[i])*helpintvec;
238  }
239
240  //check if the curve is balanced and compute its degree
241  int d = balanced(lInput);
242  if(d == 0)
243  {
244    printf("The curve is not balanced.");
245    return(-2);
246  }
247
248  //change basering, store the actual basering in a variable
249  def save = basering;
250  int n = size(lInput[1]);
251  int N = (d+2)*(d+1) div 2;
252  ring r1;     
253  ring r = 0,(x(1..n),a(1..N),t),dp;
254  setring r;
255  ideal I = fetch(save,iInput);
256  I = std(I);
257
258  if(dim(I) != (4+N))
259  {
260    printf("The ideal is not defining a projective plane.");
261    return(-2);
262  }
263
264  //for any three variables, compute the projection
265  int i2;
266  int i3;
267  int i4;
268  int j;
269  int k;
270  int l;
271  int i_w;
272  int good;
273  int i_good = 0;
274  list P;
275  intvec v;
276  intvec w;
277  ideal E;
278  list NE;
279  list S1;
280  list S2;
281  list S3;
282  poly h;
283  poly g;
284  poly coefMon;
285  matrix F;
286  matrix G;
287  list listunitvec;
288  v = 1;
289  for(i=2;i<=n+N+1;i++)
290  {
291    v = v,0;
292  }
293  listunitvec = list(v);
294  for(i=2;i<=n;i++)
295  {
296    v = 0;
297    for(j=2;j<=n+N+1;j++)
298    {
299      if(i != j)
300      {
301        v = v,0;
302      }
303      else
304      {
305        v = v,1;
306      }
307    }
308    listunitvec = listunitvec + list(v);
309  }
310  intmat M[n+N+1][n+N+1];
311  for(i=n+1;i<=n+N+1;i++)
312  {
313    M[i,i] = 1;
314  }
315  int i_start;
316  list luv1;
317  intmat M1[n+N+1][n+N+1];
318  for(i=1;i<=n-2;i++)
319  {
320    for(j=i+1;j<=n-1;j++)
321    {
322      for(k=j+1;k<=n;k++)
323      {
324        //compute the algebraic projection
325        luv1 = listunitvec;
326        luv1 = delete(luv1,k);
327        luv1 = delete(luv1,j);
328        luv1 = delete(luv1,i);
329        luv1 = luv1 + list(listunitvec[i],listunitvec[j],listunitvec[k]);
330        M1 = M;
331        for(l=1;l<=size(luv1);l++)
332        {
333          M1[l,1..(n+N+1)] = luv1[l];
334        }
335        r1 = ring(0,(x(1..n),a(1..N),t),M(M1));
336        setring r1;
337        ideal Ir1 = fetch(r,I);
338        Ir1 = std(Ir1);
339        //check if this projection is "good"
340        good = 1;
341        ideal Ii = x(i);
342        ideal Ij = x(j);
343        ideal Ik = x(k);
344        for(l=1;l<=size(Ir1);l++)
345        {
346          if((reduce(lead(Ir1[l]),Ii) == 0) or (reduce(lead(Ir1[l]),Ij) == 0) or (reduce(lead(Ir1[l]),Ik) == 0))
347          {
348            good = 0;
349          }
350        }
351        if(good == 1)
352        {
353          //for the first "good" projection, initialise the general polynomial f
354          if(i_good == 0)
355          {
356            setring r;
357            poly f = genPoly(d,i,j,k);
358            setring r1;
359            i_good = 1;
360            intvec vgood = i,j,k;
361          }
362          poly fr1 = fetch(r,f);
363          poly hr1 = reduce(fr1,Ir1);
364          setring r;
365          h = fetch(r1,hr1);
366          //compute the tropical projection
367          P = list();
368          for(l=1;l<=size(lInput);l++)
369          {
370            v = lInput[l][i],lInput[l][j],lInput[l][k];
371            P[l] = v;
372          }
373          P = simplifyList(P);
374          //collect the conditions coming from the Newton polytopes
375          S1 = list();
376          S2 = list();
377          S3 = list();
378          for(l=1;l<=size(P);l++)
379          {
380            if((P[l][1] != 0) and (P[l][2] != 0))
381            { S3 = S3 + list(P[l]); }
382            if((P[l][2] != 0) and (P[l][3] != 0))
383            { S1 = S1 + list(P[l]); }
384            if((P[l][1] != 0) and (P[l][3] != 0))
385            { S2 = S2 + list(P[l]); }
386          }
387          //sort the lists
388          S1 = sortSlope(3,2,S1);
389          S2 = sortSlope(1,3,S2);
390          S3 = sortSlope(2,1,S3);
391          //find conditions from S1
392          i_start = 0;
393          for(l=1;l<=size(S1);l++)
394          {
395            i_start = i_start + S1[l][2];
396          }
397          //find starting point
398          w = intvec(0,i_start);
399          coefMon = coefMonomial(h,x(k)^(w[2])*x(i)^(d-w[2]),n);
400          NE = NE + list(coefMon);
401          for(i2=1;i2<=size(S1);i2++)
402          {
403            w[1] = w[1] + S1[i2][3];
404            w[2] = w[2] - S1[i2][2];
405            coefMon = coefMonomial(h,x(k)^(w[2])*x(j)^(w[1])*x(i)^(d-w[1]-w[2]),n);
406            NE = NE + list(coefMon);
407            g = subst(h,x(j),x(j)*t^(S1[i2][2]),x(k),x(k)*t^(S1[i2][3]));
408            i_w = S1[i2][2]*w[1] + S1[i2][3]*w[2];
409            F = coeffs(g,t);
410            for(i3=1;i3<=i_w;i3++)
411            {
412              G = coef(F[i3,1],prodvar(n));
413              for(i4=1;i4<=ncols(G);i4++)
414              {
415                      E = E + ideal(G[2,i4]);
416              }
417            }
418          }
419          //find conditions from S2
420          i_start = 0;
421          for(l=1;l<=size(S2);l++)
422          {
423            i_start = i_start + S2[l][3];
424          }
425          //find starting point
426          w = intvec(i_start,0);
427          coefMon = coefMonomial(h,x(i)^(w[1])*x(j)^(d-w[1]),n);
428          NE = NE + list(coefMon);
429          for(i2=1;i2<=size(S2);i2++)
430          {
431            w[1] = w[1] - S2[i2][3];
432            w[2] = w[2] + S2[i2][1];
433            coefMon = coefMonomial(h,x(i)^(w[1])*x(k)^(w[2])*x(j)^(d-w[1]-w[2]),n);
434            NE = NE + list(coefMon);
435            g = subst(h,x(i),x(i)*t^(S2[i2][1]),x(k),x(k)*t^(S2[i2][3]));
436            i_w = S2[i2][3]*w[2] + S2[i2][1]*w[1];
437            F = coeffs(g,t);
438            for(i3=1;i3<=i_w;i3++)
439            {
440              G = coef(F[i3,1],prodvar(n));
441              for(i4=1;i4<=ncols(G);i4++)
442              {
443                      E = E + ideal(G[2,i4]);
444              }
445            }
446          }
447          //find conditions from S3
448          i_start = 0;
449          for(l=1;l<=size(S3);l++)
450          {
451            i_start = i_start + S3[l][1];
452          }
453          //find starting point
454          w = intvec(0,i_start);
455          coefMon = coefMonomial(h,x(j)^(w[2])*x(k)^(d-w[2]),n);
456          NE = NE + list(coefMon);
457          for(i2=1;i2<=size(S3);i2++)
458          {
459            w[1] = w[1] + S3[i2][2];
460            w[2] = w[2] - S3[i2][1];
461            coefMon = coefMonomial(h,x(i)^(w[1])*x(j)^(w[2])*x(k)^(d-w[1]-w[2]),n);
462            NE = NE + list(coefMon);
463            g = subst(h,x(i),x(i)*t^(S3[i2][1]),x(j),x(j)*t^(S3[i2][2]));
464            i_w = S3[i2][2]*w[2] + S3[i2][1]*w[1];
465            F = coeffs(g,t);
466            for(i3=1;i3<=i_w;i3++)
467            {
468              G = coef(F[i3,1],prodvar(n));
469              for(i4=1;i4<=ncols(G);i4++)
470              {
471                      E = E + ideal(G[2,i4]);
472              }
473            }
474          }
475        }
476      }
477    }
478  }
479
480  //check whether or not there is a common solution
481  setring r;
482  int isRealizable = 1;
483  E = std(E);
484  int i_dim = dim(E)-n-2;
485  for(i=1;i<=size(NE);i++)
486  {
487    if(reduce(NE[i],E) == 0)
488    {
489      isRealizable = 0;
490    }
491  }
492
493  if(isRealizable == 1)
494  {
495    setring save;
496    return(i_dim,fetch(r,E),fetch(r,NE),vgood);
497  }
498  else
499  {
500    return(-1);
501  }
502}
503
504proc realizationDim(ideal iInput, list lInput)
505"USAGE:   realizationDim(I,C); where I is a homogeneous linear ideal defining the projective plane Y = V(I) and C is a list of intvectors such that each intvector represents a one-dimensional cone in the tropical fan curve whose relative realizability should be checked. This representation is done in the following way: the one-dimensional cone K is represented by a vector w whose equivalence class [w] in R^n/<1> can be written as [w] = m*[v] where [v] is the primitive generator of K and m is the weight of K.
506RETURNS:  the dimension of the relative realization space of the tropical curve C with respect to Y, and -1 if the relative realization space is empty.
507EXAMPLE:  realizationDim; shows an example"
508{
509  int ret = realizationDimIdeal(iInput,lInput)[1];
510  if(ret[1] == -2)
511  {
512    printf("WARNING: no computation possible, return value is not meaningful!");
513    return(-2);
514  }
515  else
516  {
517    return(ret);
518  }
519}
520example
521{
522  "EXAMPLE:"; echo=2;
523  ring r = 0,(x(1..4)),dp;
524  ideal I = x(1)+x(2)+x(3)+x(4);
525  list C = list(intvec(2,2,0,0),intvec(0,0,2,1),intvec(0,0,0,1));
526  //C represents the tropical fan curve which consists of the cones
527  //cone([(1,1,0,0)]) (with weight 2), cone([(0,0,2,1)]) (with weight 1)
528  //and cone([(0,0,0,1)]) (with weight 1)
529  realizationDim(I,C);
530}
531
532proc irrRealizationDim(ideal iInput, list lInput)
533"USAGE:   irrRealizationDim(I,C); where I is a homogeneous linear ideal defining the projective plane Y = V(I) and C is a list of intvectors such that each intvector represents a one-dimensional cone in the tropical fan curve whose irreducible relative realizability should be checked. This representation is done in the following way: a one-dimensional cone K is represented by a vector w whose equivalence class [w] in R^n/<1> can be written as [w] = m*[v] where [v] is the primitive generator of K and m is the weight of K.
534RETURNS:  the dimension of the irreducible relative realization space of C with respect to Y, and -1 if the irreducible realization space is empty.
535EXAMPLE:  irrRealizationDim; shows an example"
536{
537  int i;
538  int i_dim = realizationDim(iInput,lInput);
539  if(i_dim > -1)
540  {
541    //check if also realizable by an irreducible curve
542    list lweight;
543    int i_rdim = -1;
544    //substitute the vectors by a primitve one and store the multiplicities
545    for(i=1;i<=size(lInput);i++)
546    {
547      lweight[i] = gcdvector(lInput[i]);
548      lInput[i] = lInput[i] div lweight[i];
549    }
550    //find all decompositions into two tropical curves
551    intvec tm;
552    for(i=1;i<=size(lInput);i++)
553    {
554      tm[i] = 0;
555    }
556    int na;
557    list C1;
558    list C2;
559    int dimC1;
560    int dimC2;
561    while(na==0)
562    {
563      na = 1;
564      for(i=1;i<=size(lInput);i++)
565      {
566        if(tm[i] < lweight[i])
567        {
568          tm[i] = tm[i]+1;
569          na = 0;
570          i = size(lInput);
571        }
572        else
573        {
574          tm[i] = 0;
575        }
576      }
577      if(na == 0)
578      {
579        C1 = list();
580        C2 = list();
581        for(i=1;i<=size(lInput);i++)
582        {
583          if(tm[i] > 0)
584          {
585            C1 = C1 + list(tm[i]*lInput[i]);
586            if(tm[i] < lweight[i])
587            {
588              C2 = C2 + list((lweight[i]-tm[i])*lInput[i]);
589            }
590          }
591          else
592          {
593            C2 = C2 + list(lweight[i]*lInput[i]);
594          }
595        }
596        if((balanced(C2) != 0) and (balanced(C2) <= balanced(C1)))
597        {
598          dimC1 = realizationDim(iInput,C1);
599          dimC2 = realizationDim(iInput,C2);
600          if((dimC1 >= 0) and (dimC2 >= 0))
601          {
602            i_rdim = Max(intvec(i_rdim,dimC1 + dimC2));
603          }
604        }
605      }
606    }
607    if(i_rdim < i_dim)
608    {
609      return(i_dim);
610    }
611    else
612    {
613      return(-1);
614    }
615  }
616  else
617  {
618    return(-1);
619  }
620}
621example
622{
623  "EXAMPLE:"; echo=2;
624  ring r = 0,(x(1..4)),dp;
625  ideal I = x(1)+x(2)+x(3)+x(4);
626  list C = list(intvec(2,2,0,0),intvec(0,0,2,2));
627  //C represents the tropical fan curve which consists of the cones
628  //cone([(1,1,0,0)]) and cone([(1,1,0,0)]), both with weight 2
629  realizationDim(I,C);
630  irrRealizationDim(I,C);
631}
632
633proc realizationDimPoly(ideal iInput, list lInput)
634"USAGE:   realizationDimPoly(I,C); where I is a homogeneous linear ideal defining the projective plane Y = V(I) and C is a list of intvectors such that each intvector represents a one-dimensional cone in the tropical fan curve whose relative realizability should be checked. This representation is done in the following way: the one-dimensional cone K is represented by a vector w whose equivalence class [w] in R^n/<1> can be written as [w] = m*[v] where [v] is the primitive generator of K and m is the weight of K.
635RETURNS:  If the relative realization space of the tropical fan curve C is non-empty, this routine returns the tuple (r,f), where r is the dimension of the relative realization space and f is an example of a homogeneous polynomial of degree deg(C) cutting out a curve X in Y which tropicalizes to C. In case the relative realization space is empty, the output is set to -1.
636EXAMPLE:  realizationDimPoly; shows an example"
637{
638  def save = basering;
639  int d = balanced(lInput);
640  int n = size(lInput[1]);
641  int N = (d+2)*(d+1) div 2; 
642  int i;
643  ring r = 0,(x(1..n),a(1..N)),dp;
644  list ret = realizationDimIdeal(fetch(save,iInput),lInput);
645  int realdim = ret[1];
646  if(realdim != -1)
647  {
648    ideal E = ret[2];
649    list NE = ret[3];
650    E = std(E);
651    //find variables which are free to choose
652    intvec v;
653    for(i=1;i<=size(E);i++)
654    {
655      v = v + leadexp(E[i]);
656    }
657    int j;
658    int k;
659    int boolean;
660    ideal E1;
661    list NE1;
662    poly f;
663    poly g;
664    //initialize the list of the free variables
665    list lValues;
666    if(size(v) > 1)
667    {
668      for(j=1;j<=N;j++)
669      {
670        if(v[j+n] == 0)
671        {
672          lValues = lValues + list(list(a(j),0));
673        }
674      }
675    }
676    else
677    {
678      for(j=1;j<=N;j++)
679      {
680        lValues = lValues + list(list(a(j),0));
681      }
682    }
683    //try to find an easy solution
684    boolean = 1;
685    for(j=1;j<=size(lValues);j++)
686    {
687      if(boolean == 1)
688      {
689        lValues[j][2] = 0;
690      }
691      else
692      {
693        lValues[j][2] = lValues[j][2] + 1;
694      }
695      boolean = 1;
696      E1 = E;
697      for(i=1;i<=size(E1);i++)
698      {
699        for(k=1;k<=j;k++)
700        {
701          E1[i] = subst(E1[i],lValues[k][1],lValues[k][2]);
702        }
703      }
704      NE1 = NE;
705      for(i=1;i<=size(NE);i++)
706      {
707        for(k=1;k<=j;k++)
708        {
709          NE1[i] = subst(NE1[i],lValues[k][1],lValues[k][2]);
710        }
711      }
712      E1 = std(E1);
713      for(i=1;i<=size(NE1);i++)
714      {
715        if(reduce(NE1[i],E1) == 0)
716        {
717          boolean = 0;
718        }
719      }
720      if(boolean == 0)
721      {
722        j = j-1;
723      }
724    }
725    //compute the values of the dependent variables
726    for(j=1;j<=size(E);j++)
727    {
728      f = E[j];
729      for(k=1;k<=size(lValues);k++)
730      {
731        f = subst(f,lValues[k][1],lValues[k][2]);
732      }
733      if(leadcoef(f) != 1)
734      {
735        for(k=1;k<=size(lValues);k++)
736        {
737          lValues[k][2] = lValues[k][2] * leadcoef(f);
738        }
739      }
740      f = subst(f,leadmonom(f),0);
741      lValues = lValues + list(list(leadmonom(E[j]),-f));
742    }
743    g = genPoly(d,ret[4][1],ret[4][2],ret[4][3]);
744    for(j=1;j<=N;j++)
745    {
746      g = subst(g,lValues[j][1],lValues[j][2]);
747    }
748    setring save;
749    return(realdim,fetch(r,g));
750  }
751  else
752  {
753    return(-1);
754  }
755}
756example
757{
758  "EXAMPLE:"; echo=2;
759  ring r = 0,(x(1..4)),dp;
760  ideal I = x(1)+x(2)+x(3)+x(4);
761  list C = list(intvec(2,2,0,0),intvec(0,0,2,2));
762  //C represents the tropical fan curve which consists of the cones
763  //cone([(1,1,0,0)]) and cone([(1,1,0,0)]), both with weight 2
764  realizationDimPoly(I,C);
765  C = list(intvec(0,0,0,4),intvec(0,1,3,0),intvec(1,0,1,0),intvec(0,2,0,0),intvec(3,1,0,0));
766  //C represents the tropical fan curve which consists of the cones
767  //cone([(0,0,0,1)]) with weight 4,
768  //cone([(0,1,3,0)]), cone([(1,0,1,0)]) both with weight 1,
769  //cone([(0,1,0,0)]) with weight 2, and
770  //cone([(3,1,0,0)]) with weight 1
771  realizationDimPoly(I,C);
772}
Note: See TracBrowser for help on using the repository browser.