1 | ///////////////////////////////////////////////////////////////////////////// |
---|
2 | version="$Id$"; |
---|
3 | category="Tropical Geometry"; |
---|
4 | info=" |
---|
5 | LIBRARY: realizationMatroids.lib Deciding Relative Realizability for Tropical Fan Curves in 2-Dimensional Matroidal Fans |
---|
6 | AUTHORS: Anna Lena Winstel, winstel@mathematik.uni-kl.de |
---|
7 | OVERVIEW: 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 | |
---|
9 | This 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 | |
---|
11 | NOTATION: 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 | |
---|
13 | PROCEDURES: |
---|
14 | |
---|
15 | realizationDim(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 | |
---|
17 | irrRealizationDim(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 | |
---|
19 | realizationDimPoly(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 | |
---|
23 | LIB "control.lib"; |
---|
24 | LIB "qhmoduli.lib"; |
---|
25 | |
---|
26 | static 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 | |
---|
41 | static 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 | |
---|
79 | static 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 | |
---|
96 | static 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 | |
---|
107 | static 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 | |
---|
119 | static 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 | |
---|
139 | static 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 | |
---|
153 | static 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 | |
---|
194 | static 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 | |
---|
225 | static 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 | |
---|
504 | proc 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. |
---|
506 | RETURNS: 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. |
---|
507 | EXAMPLE: 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 | } |
---|
520 | example |
---|
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 | |
---|
532 | proc 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. |
---|
534 | RETURNS: the dimension of the irreducible relative realization space of C with respect to Y, and -1 if the irreducible realization space is empty. |
---|
535 | EXAMPLE: 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 | } |
---|
621 | example |
---|
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 | |
---|
633 | proc 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. |
---|
635 | RETURNS: 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. |
---|
636 | EXAMPLE: 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 | } |
---|
756 | example |
---|
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 | } |
---|