[d55b3c] | 1 | /////////////////////////////////////////////////////////////////////////////// |
---|
| 2 | version="$Id$"; |
---|
| 3 | category="Commutative Algebra"; |
---|
| 4 | info=" |
---|
| 5 | LIBRARY: ellipticCovers.lib Gromov Witten numbers of elliptic curves |
---|
| 6 | |
---|
| 7 | AUTHORS: J. Boehm, boehm @ mathematik.uni-kl.de |
---|
| 8 | A. Buchholz, buchholz @ math.uni-sb.de |
---|
| 9 | H. Markwig hannah @ math.uni-sb.de |
---|
| 10 | |
---|
| 11 | OVERVIEW: |
---|
| 12 | |
---|
[ca9c14] | 13 | We implement a formula for computing the number of covers of elliptic curves |
---|
| 14 | which has beed proved by proving mirror symmetry |
---|
| 15 | for arbitrary genus by tropical methods in [BBM]. A Feynman graph of genus |
---|
| 16 | g, which is defined as a trivalent genus g connected graph (with 2g-2 vertices |
---|
| 17 | and 3g-3 edges). The branch type a=(a_1,...,a_(3g-3)) of a stable map is the |
---|
| 18 | multiplicity of the the edge i over a fixed base point. |
---|
| 19 | |
---|
| 20 | Given a Feynman graph and a branch type a, we compute the number |
---|
| 21 | N_(Gamma,a) of stable maps from a genus g curve of topological type Gamma |
---|
| 22 | and branch type a to the elliptic curve by computing a path integral |
---|
| 23 | over a rational function (as a residue). |
---|
| 24 | |
---|
| 25 | The sum of N_(Gamma,a) over all branch types a of sum d gives the |
---|
| 26 | Gromov-Witten invariant N_(Gamma,d) of degree d stable maps from a genus g curve |
---|
| 27 | of topological type Gamma to the elliptic curve. |
---|
| 28 | |
---|
| 29 | The sum of N_(Gamma,d) over all such graphs gives the usual Gromov-Witten invariant N_(g,d) |
---|
| 30 | of degree d stable maps from a genus g curve to the elliptic curve. |
---|
| 31 | |
---|
| 32 | References: |
---|
| 33 | |
---|
| 34 | [BBM] J. Boehm, A. Buchholz, H. Markwig: Tropical mirror symmetry for elliptic curves. |
---|
| 35 | |
---|
[d55b3c] | 36 | KEYWORDS: |
---|
| 37 | |
---|
[ca9c14] | 38 | tropical geometry; mirror symmetry; tropical mirror symmetry; Gromov-Witten invariants; elliptic curves; propagator; Feynman graph; path integral |
---|
| 39 | |
---|
[d55b3c] | 40 | TYPES: |
---|
| 41 | |
---|
[ca9c14] | 42 | graph |
---|
| 43 | |
---|
[d55b3c] | 44 | PROCEDURES: |
---|
| 45 | |
---|
[ca9c14] | 46 | makeGraph(list, list) graph from lists of vertices and edges; |
---|
| 47 | propagator(list, int) propagator factor of degree d in the quotient of two variables |
---|
| 48 | propagator(graph, list) propagator for fixed graph and branch type |
---|
| 49 | computeConstant(number, number) constant coefficient in the Laurent series expansion of a rational function in a given variable |
---|
| 50 | evalutateIntegral(number, list) path integral for a given propagator and ordered sequence of variables |
---|
| 51 | gromovWitten(number) sum of path integrals for a given propagator over all orderings of the variables |
---|
| 52 | gromovWitten(graph, int) list of Gromov Witten invariants for a given graph and all branch types |
---|
| 53 | |
---|
| 54 | partitions(int, int) partitions of an integer in a fixed number of summands |
---|
| 55 | permute(list) all permutations of a list |
---|
| 56 | sum(list) sum of the elements of a list |
---|
| 57 | max(int, int) compute the maximum |
---|
| 58 | |
---|
[d55b3c] | 59 | "; |
---|
| 60 | |
---|
| 61 | |
---|
| 62 | LIB "parallel.lib"; |
---|
| 63 | |
---|
| 64 | |
---|
| 65 | proc mod_init() |
---|
| 66 | { |
---|
| 67 | newstruct("graph","list vertices, list edges"); |
---|
| 68 | newstruct("Net","list rows"); |
---|
| 69 | |
---|
| 70 | system("install","graph","print",printGraph,1); |
---|
| 71 | system("install","Net","print",printNet,1); |
---|
| 72 | system("install","Net","+",catNet,2); |
---|
| 73 | |
---|
| 74 | } |
---|
| 75 | |
---|
| 76 | |
---|
| 77 | proc max(int n, int m){ |
---|
| 78 | if (n>m){return(n);} |
---|
| 79 | return(m);} |
---|
| 80 | |
---|
| 81 | |
---|
| 82 | proc catNet(Net N, Net M) |
---|
| 83 | { |
---|
| 84 | list L; |
---|
| 85 | list LN=N.rows; |
---|
| 86 | list LM=M.rows; |
---|
| 87 | int widthN=size(LN[1]); |
---|
| 88 | int widthM=size(LM[1]); |
---|
| 89 | int nm=max(size(LN),size(LM)); |
---|
| 90 | for (int j=1; j<=nm; j++) |
---|
| 91 | { |
---|
| 92 | if (j>size(LN)){LN[j]=emptyString(widthN);} |
---|
| 93 | if (j>size(LM)){LM[j]=emptyString(widthM);} |
---|
| 94 | L[j]=LN[j]+LM[j]; |
---|
| 95 | } |
---|
| 96 | Net NM; |
---|
| 97 | NM.rows=L; |
---|
| 98 | return(NM);} |
---|
| 99 | |
---|
| 100 | |
---|
| 101 | proc netList(list L1) |
---|
| 102 | { |
---|
| 103 | Net N=net("["); |
---|
| 104 | for (int j=1; j<=size(L1)-1; j++) |
---|
| 105 | { |
---|
| 106 | N=N+net(L1[j])+net(", "); |
---|
| 107 | } |
---|
| 108 | N=N+net(L1[size(L1)])+net("]"); |
---|
| 109 | return(N); |
---|
| 110 | } |
---|
| 111 | |
---|
| 112 | proc printNet(Net N) |
---|
| 113 | { |
---|
| 114 | list L = N.rows; |
---|
| 115 | for (int j=1; j<=size(L); j++) |
---|
| 116 | { |
---|
| 117 | print(L[j]); |
---|
| 118 | } |
---|
| 119 | } |
---|
| 120 | |
---|
| 121 | proc net(def M){ |
---|
| 122 | if (typeof(M)=="list"){ |
---|
| 123 | return(netList(M)); |
---|
| 124 | } |
---|
| 125 | Net N; |
---|
| 126 | list L; |
---|
| 127 | L[1]=string(M); |
---|
| 128 | N.rows=L; |
---|
| 129 | return(N);} |
---|
| 130 | |
---|
| 131 | |
---|
| 132 | |
---|
| 133 | proc printGraph(graph G) |
---|
| 134 | { |
---|
| 135 | print(netList(G.edges)); |
---|
| 136 | print("Graph with "+string(size(G.vertices))+" vertices and "+string(size(G.edges))+" edges") |
---|
| 137 | } |
---|
| 138 | |
---|
| 139 | |
---|
| 140 | |
---|
| 141 | proc makeGraph(list v, list e) |
---|
| 142 | { |
---|
| 143 | graph G; |
---|
| 144 | G.vertices = v; |
---|
| 145 | G.edges = e; |
---|
| 146 | return(G); |
---|
| 147 | } |
---|
| 148 | |
---|
| 149 | |
---|
| 150 | proc propagator(def xy, def d) |
---|
| 151 | { |
---|
| 152 | if ((typeof(xy)=="list")||(typeof(d)=="int")) { |
---|
| 153 | number x = xy[1]; |
---|
| 154 | number y = xy[2]; |
---|
| 155 | if (d<0) {ERROR("expected non-negative degree");} |
---|
| 156 | if (d==0) {return(x^2*y^2/(x^2-y^2)^2);} |
---|
| 157 | number p=0; |
---|
| 158 | for (int j=1; j<=d; j++){ |
---|
| 159 | if (d%j==0){p=p+(j*x^(4*j)+j*y^(4*j))/(x*y)^(2*j);} |
---|
| 160 | } |
---|
| 161 | return(p); |
---|
| 162 | } |
---|
| 163 | if ((typeof(xy)=="graph")||(typeof(d)=="list")) { |
---|
| 164 | list xl = ringlist(R)[1][2]; |
---|
| 165 | list ed = xy.edges; |
---|
| 166 | number f=1; |
---|
| 167 | for (int j=1; j<=size(ed); j++){ |
---|
| 168 | execute("number xx1 = "+xl[ed[j][1]]); |
---|
| 169 | execute("number xx2 = "+xl[ed[j][2]]); |
---|
| 170 | f=f*propagator(list(xx1,xx2),d[j]); |
---|
| 171 | kill xx1; |
---|
| 172 | kill xx2; |
---|
| 173 | } |
---|
| 174 | return(f); |
---|
| 175 | } |
---|
| 176 | if ((typeof(xy)=="graph")||(typeof(d)=="int")) { |
---|
| 177 | } |
---|
| 178 | ERROR("wrong input type");} |
---|
| 179 | |
---|
| 180 | proc computeConstant(number f,number xx) |
---|
| 181 | { |
---|
| 182 | int tst=0; |
---|
| 183 | number ff=f; |
---|
| 184 | int k; |
---|
| 185 | int j; |
---|
| 186 | poly de; |
---|
| 187 | while (tst==0){ |
---|
| 188 | ff=f*xx^k; |
---|
| 189 | for (j=1; j<=k; j++){ |
---|
| 190 | ff=diff(ff,xx)/j; |
---|
| 191 | } |
---|
| 192 | de = subst(denominator(ff),xx,0); |
---|
| 193 | if (de!=0){ |
---|
| 194 | poly nu = subst(numerator(ff),xx,0); |
---|
| 195 | return(number(nu/de)); |
---|
| 196 | } |
---|
| 197 | k=k+1; |
---|
| 198 | } |
---|
| 199 | ERROR("error in computeConstant");} |
---|
| 200 | |
---|
| 201 | proc evaluateIntegral(number P, list xL) |
---|
| 202 | { |
---|
| 203 | number p = P; |
---|
| 204 | for(int j=1; j<=size(xL); j++){ |
---|
| 205 | p=computeConstant(p,xL[j]); |
---|
| 206 | } |
---|
| 207 | return(p);} |
---|
| 208 | |
---|
| 209 | |
---|
| 210 | proc permute (list N) |
---|
| 211 | { |
---|
| 212 | int i,j,k; |
---|
| 213 | list L,L1; |
---|
| 214 | if (size(N)==1){ |
---|
| 215 | return(list(N)); |
---|
| 216 | } else { |
---|
| 217 | k=1; |
---|
| 218 | for (i=1; i<=size(N); i++){ |
---|
| 219 | L=permute(delete(N,i)); |
---|
| 220 | for (j=1; j<=size(L); j++){ |
---|
| 221 | L1[k]=L[j]+list(N[i]); |
---|
| 222 | k=k+1; |
---|
| 223 | } |
---|
| 224 | } |
---|
| 225 | } |
---|
| 226 | return(L1);} |
---|
| 227 | |
---|
| 228 | //permute(list(x1,x2,x3,x4)); |
---|
| 229 | |
---|
| 230 | |
---|
| 231 | proc partitions(int n, int a){ |
---|
| 232 | ring R = 2,(x(1..n)),dp; |
---|
| 233 | ideal I = maxideal(a); |
---|
| 234 | list L; |
---|
| 235 | for (int j=1;j<=size(I);j++){ |
---|
| 236 | L[j]=leadexp(I[j]); |
---|
| 237 | } |
---|
| 238 | return(L);} |
---|
| 239 | |
---|
| 240 | |
---|
| 241 | proc gromovWitten(def P,list #) |
---|
| 242 | { |
---|
| 243 | if (typeof(P)=="number") { |
---|
| 244 | list xl = ringlist(R)[1][2]; |
---|
| 245 | int j; |
---|
| 246 | for(j=1; j<=size(xl); j++){ |
---|
| 247 | execute("number n= "+xl[j]); |
---|
| 248 | xl[j]=n; |
---|
| 249 | kill n; |
---|
| 250 | } |
---|
| 251 | list pxl = permute(xl); |
---|
| 252 | number p = 0; |
---|
| 253 | for(j=1; j<=size(pxl); j++){ |
---|
| 254 | p=p+evaluateIntegral(P,pxl[j]); |
---|
| 255 | } |
---|
| 256 | return(p); |
---|
| 257 | } |
---|
| 258 | if (typeof(P)=="graph"){ |
---|
[ca9c14] | 259 | if (size(#)==1){ |
---|
[d55b3c] | 260 | int d =#[1]; |
---|
[ca9c14] | 261 | list pa = partitions(size(P.edges),d); |
---|
| 262 | return(gromovWitten(P,list(#[1],1,size(pa)))); |
---|
| 263 | } else { |
---|
| 264 | int d =#[1]; |
---|
| 265 | int st = #[2]; |
---|
| 266 | int en = #[3]; |
---|
[d55b3c] | 267 | number s =0; |
---|
| 268 | number p; |
---|
| 269 | list pararg; |
---|
| 270 | list re; |
---|
| 271 | list pa = partitions(size(P.edges),d); |
---|
| 272 | int ti; |
---|
[ca9c14] | 273 | int ct=1; |
---|
| 274 | print(size(pa)); |
---|
[d55b3c] | 275 | for (int j=1; j<=size(pa); j++) { |
---|
[ca9c14] | 276 | if ((j>=st)&(j<=en)){ |
---|
[d55b3c] | 277 | ti=timer; |
---|
| 278 | //pararg[j]=list(propagator(G,pa[j])); |
---|
| 279 | re[j]=gromovWitten(propagator(G,pa[j])); |
---|
| 280 | ti=timer-ti; |
---|
[ca9c14] | 281 | print(string(j)+" / "+string(size(pa))+" "+string(pa[j])+" "+string(re[j])+" "+string(sum(re))+" "+string(ti)); |
---|
| 282 | } else {re[j]=0;} |
---|
[d55b3c] | 283 | } |
---|
| 284 | //list re = parallelWaitAll("gromovWitten", pararg, list(list(list(2)))); |
---|
| 285 | return(re); |
---|
[ca9c14] | 286 | } |
---|
[d55b3c] | 287 | } |
---|
| 288 | } |
---|
| 289 | |
---|
| 290 | proc sum(list L){ |
---|
| 291 | number s; |
---|
| 292 | for(int j=1; j<=size(L); j++){ |
---|
| 293 | s=s+L[j]; |
---|
| 294 | } |
---|
| 295 | return(s);} |
---|
| 296 | |
---|
| 297 | |
---|
| 298 | |
---|