1 | ////////////////////////////////////////////////////////////////////// |
---|
2 | version="version JMSConst.lib 4.1.1.0 Dec_2017 "; // $Id$ |
---|
3 | category="Algebraic Geometry"; |
---|
4 | // summary description of the library |
---|
5 | info=" |
---|
6 | LIBRARY: JMSConst.lib A library for Singular which constructs J-Marked Schemes. |
---|
7 | AUTHOR: Michela Ceria, email: michela.ceria@unito.it |
---|
8 | |
---|
9 | SEE ALSO: JMBTest_lib |
---|
10 | |
---|
11 | KEYWORDS: J-marked schemes, Borel ideals |
---|
12 | |
---|
13 | OVERVIEW: |
---|
14 | The library performs the J-marked computation, as described in [BCLR]. |
---|
15 | As in JMBTest.lib we construct the V polynomials and we reduce the EK |
---|
16 | polynomials w.r.t. them, putting the coefficients as results. |
---|
17 | |
---|
18 | |
---|
19 | The algorithm terminates only if the ordering is rp. |
---|
20 | Anyway, the number of reduction steps is bounded. |
---|
21 | |
---|
22 | REFERENCES: |
---|
23 | [CR] Francesca Cioffi, Margherita Roggero,Flat Families by Strongly |
---|
24 | Stable Ideals and a Generalization of Groebner Bases, |
---|
25 | J. Symbolic Comput. 46, 1070-1084, (2011).@* |
---|
26 | [BCLR] Cristina Bertone, Francesca Cioffi, Paolo Lella, |
---|
27 | Margherita Roggero, Upgraded methods for the effective |
---|
28 | computation of marked schemes on a strongly stable ideal, |
---|
29 | Journal of Symbolic Computation |
---|
30 | (2012), http://dx.doi.org/10.1016/j.jsc.2012.07.006 @* |
---|
31 | |
---|
32 | |
---|
33 | |
---|
34 | SEE ALSO: JMSConst_lib |
---|
35 | PROCEDURES: |
---|
36 | BorelCheck(ideal,r) checks whether the given ideal is Borel |
---|
37 | JMarkedScheme(list, list, list, int) computes authomatically all the J-marked scheme |
---|
38 | "; |
---|
39 | LIB "presolve.lib"; |
---|
40 | LIB "qhmoduli.lib"; |
---|
41 | LIB "monomialideal.lib"; |
---|
42 | //////////////////////////////////////////////////////////////////// |
---|
43 | proc BorelCheck(ideal Borid,def r) |
---|
44 | "USAGE: BorelCheck(Borid,r); Borid ideal, r ring |
---|
45 | RETURN: int: d |
---|
46 | NOTE: Input must be a monomial ideal. |
---|
47 | The procedure checks whether the Borel moves produce elements belonging to Borid. |
---|
48 | EXAMPLE: example QuanteC; shows an example" |
---|
49 | { |
---|
50 | int n= nvars(r); |
---|
51 | int b=1; |
---|
52 | int i=1; |
---|
53 | int k; |
---|
54 | intvec v; |
---|
55 | int j; |
---|
56 | int u; |
---|
57 | //b =bool. b=1 true; b=0 false |
---|
58 | //we suppose true! |
---|
59 | //i=counter on the elements of Borid |
---|
60 | int s= size(Borid); |
---|
61 | while(b && i<=s) |
---|
62 | { |
---|
63 | v=leadexp(Borid[i]); |
---|
64 | j=1; |
---|
65 | u=size(v); |
---|
66 | while(b && j<=u) |
---|
67 | { |
---|
68 | if(v[j]!=0) |
---|
69 | { |
---|
70 | k=j+1; |
---|
71 | while(b && k<=n) |
---|
72 | { |
---|
73 | b=(reduce(Borid[i]*var(k)/var(j),std(Borid))==0); |
---|
74 | k++; |
---|
75 | } |
---|
76 | } |
---|
77 | j++; |
---|
78 | } |
---|
79 | i++; |
---|
80 | } |
---|
81 | return(b); |
---|
82 | } |
---|
83 | example |
---|
84 | { "EXAMPLE:"; echo = 2; |
---|
85 | ring r=0, (x,y,z),rp; |
---|
86 | ideal Borid=y^2*z,y*z^2,z^3,y^5; |
---|
87 | BorelCheck(Borid,r); |
---|
88 | } |
---|
89 | //////////////////////////////////////////////////////////////////// |
---|
90 | proc ArrangeBorel(ideal Borid) |
---|
91 | "USAGE: ArrangeBorel(Borid); Borid ideal |
---|
92 | RETURN: list: Input |
---|
93 | NOTE: Input must be a monomial ideal, increasingly ordered by degree. |
---|
94 | The procedure groups the monomials in a list of lists as needed to compute J-marked scheme. |
---|
95 | // It also returns a list containing the size of every sublist generated. |
---|
96 | EXAMPLE: example ArrangeBorel; shows an example" |
---|
97 | { |
---|
98 | list Input; |
---|
99 | int j=1; |
---|
100 | //list numero=1; |
---|
101 | Input[1]=list(Borid[1]); |
---|
102 | for(int i=2; i<=size(Borid); i++) |
---|
103 | { |
---|
104 | if(deg(Borid[i])!=deg(Borid[i-1])) |
---|
105 | { |
---|
106 | j++; |
---|
107 | Input[j]=list(); |
---|
108 | // numero[j]=0; |
---|
109 | } |
---|
110 | Input[j]=insert(Input[j],Borid[i],size(Input[j])); |
---|
111 | //numero[j]=numero[j]+1; |
---|
112 | } |
---|
113 | return(Input); |
---|
114 | } |
---|
115 | example |
---|
116 | { "EXAMPLE:"; echo = 2; |
---|
117 | ring r=0, (x,y,z),rp; |
---|
118 | ideal Borid=y^2*z,y*z^2,z^3,y^5; |
---|
119 | ArrangeBorel(Borid); |
---|
120 | } |
---|
121 | //////////////////////////////////////////////////////////////////// |
---|
122 | proc NumNewVar(list B, list NumN) |
---|
123 | "USAGE: NumNewVar(B,NumN); B list, NumN list |
---|
124 | RETURN: int: d |
---|
125 | NOTE: B is the grouped Borel, while NumN is a list containing the cardinalities of the obtained groups. |
---|
126 | EXAMPLE: example NumNewVar; shows an example" |
---|
127 | { |
---|
128 | int d; |
---|
129 | int j; |
---|
130 | int i; |
---|
131 | for(i=1; i<=size(B); i++) |
---|
132 | { |
---|
133 | d=d+size(B[i])*NumN[i]; |
---|
134 | } |
---|
135 | return(d); |
---|
136 | } |
---|
137 | example |
---|
138 | { "EXAMPLE:"; echo = 2; |
---|
139 | ring r=0, (x,y,z),rp; |
---|
140 | ideal Borid=y^2*z,y*z^2,z^3,y^5; |
---|
141 | list B= ArrangeBorel(Borid); |
---|
142 | list NumN=7,8; |
---|
143 | NumNewVar(B,NumN); |
---|
144 | } |
---|
145 | //////////////////////////////////////////////////////////////////// |
---|
146 | proc NewTails(ideal NI, int s) |
---|
147 | "USAGE: NewTails(NI,s); NI ideal, s int |
---|
148 | RETURN: list: M |
---|
149 | NOTE: The procedure construct the tails of the required unknown J-marked polynomials. |
---|
150 | EXAMPLE: example NewTails; shows an example" |
---|
151 | { |
---|
152 | poly p=0; |
---|
153 | for(int i=1; i<=size(NI); i++)//Loop on the Groebner escalier |
---|
154 | { |
---|
155 | p=p+NI[i]*c(i+s); //multiply by c's |
---|
156 | } |
---|
157 | int u=size(NI); |
---|
158 | list M=p,u; |
---|
159 | return(M); |
---|
160 | } |
---|
161 | example |
---|
162 | { "EXAMPLE:"; echo = 2; |
---|
163 | ring r=(0,c(1..7)), (x,y,z),rp; |
---|
164 | ideal NI=x^2,x*y,y^2,z^2; |
---|
165 | NewTails(NI,3); |
---|
166 | } |
---|
167 | //////////////////////////////////////////////////////////////////// |
---|
168 | proc ArrangeTails(list Q) |
---|
169 | "USAGE: ArrangeTails(Q); Q list |
---|
170 | RETURN: list: Q |
---|
171 | NOTE: Constructs the final list of J-marked polynomials. |
---|
172 | EXAMPLE: example FormaInput; shows an example" |
---|
173 | { |
---|
174 | jmp m=Q[1][1]; |
---|
175 | jmp M=Q[size(Q)][1]; |
---|
176 | int minimo=deg(m.h); |
---|
177 | int massimo=deg(M.h); |
---|
178 | //print(minimo); |
---|
179 | //print(massimo); |
---|
180 | int i=2; |
---|
181 | jmp qi; |
---|
182 | while(i<=size(Q)) |
---|
183 | { |
---|
184 | //print("entro nel ciclo"); |
---|
185 | //print(i); |
---|
186 | qi=Q[i][1]; |
---|
187 | if(deg(qi.h)!=minimo+1) |
---|
188 | { |
---|
189 | //print("qui riempire"); |
---|
190 | //print(i); |
---|
191 | Q=insert(Q,list(),i-1);//Insert empty list for all intermediate degree between the minimum and the maximum, not having polynomials. |
---|
192 | //print(Q); |
---|
193 | } |
---|
194 | minimo=minimo+1; |
---|
195 | i=i+1; |
---|
196 | //print("ora ho"); |
---|
197 | //print(minimo); |
---|
198 | //print(i); |
---|
199 | } |
---|
200 | return(Q); |
---|
201 | } |
---|
202 | example |
---|
203 | { "EXAMPLE:"; echo = 2; |
---|
204 | ring r=0, (x,y,z),rp; |
---|
205 | ideal Borid=y^2*z,y*z^2,z^3,y^5; |
---|
206 | attrib(Borid,"isSB",1); |
---|
207 | list B=ArrangeBorel(Borid); |
---|
208 | list NumN; |
---|
209 | list N; |
---|
210 | int i; |
---|
211 | int d; |
---|
212 | for(i=1;i<=size(B);i++) |
---|
213 | { |
---|
214 | d=deg(B[i][1]); |
---|
215 | N[i]=kbase(Borid,d); |
---|
216 | NumN[i]=size(N[i]); |
---|
217 | } |
---|
218 | int qc=NumNewVar(B, NumN); |
---|
219 | //Now I must define the NEW RING, putting the c parameters inside. |
---|
220 | list L=ringlist(r); |
---|
221 | list L2; |
---|
222 | L2[1]=L[1]; |
---|
223 | L2[2]=list(); |
---|
224 | for(i=qc;i>=1;i--) |
---|
225 | { |
---|
226 | L2[2][i]="c("+string(i)+")"; |
---|
227 | } |
---|
228 | L2[3]=list(list("rp",qc)); |
---|
229 | L2[4]=L[4]; |
---|
230 | L[1]=L2; |
---|
231 | def K=ring(L); |
---|
232 | setring(K); |
---|
233 | ideal Borid=imap(r,Borid); |
---|
234 | list N=imap(r,N); |
---|
235 | list B=imap(r,B); |
---|
236 | //NumN contains only scalars so I do not imap it |
---|
237 | int j; |
---|
238 | list Q; |
---|
239 | int s; |
---|
240 | list M; |
---|
241 | jmp pp; |
---|
242 | for(i=1;i<=size(B);i++) |
---|
243 | { |
---|
244 | Q[i]=list(); |
---|
245 | for(j=1;j<=size(B[i]);j++) |
---|
246 | { |
---|
247 | M=NewTails(N[i],s); |
---|
248 | pp.h=B[i][j]; |
---|
249 | pp.t=M[1]; |
---|
250 | Q[i][j]=pp; |
---|
251 | s=s+M[2]; |
---|
252 | //print(s); |
---|
253 | } |
---|
254 | } |
---|
255 | list P=ArrangeTails(Q); |
---|
256 | int ll; |
---|
257 | int uu; |
---|
258 | jmp Pp; |
---|
259 | for(ll=1; ll<=size(P);ll++) |
---|
260 | { |
---|
261 | for(uu=1;uu<=size(P[ll]);uu++) |
---|
262 | {Pp=P[ll][uu]; Pp.h; Pp.t;} |
---|
263 | } |
---|
264 | } |
---|
265 | //////////////////////////////////////////////////////////////////// |
---|
266 | proc mod_init() |
---|
267 | "USAGE: mod_init(); |
---|
268 | RETURN: struct: jmp |
---|
269 | EXAMPLE: example mod_init; shows an example" |
---|
270 | { |
---|
271 | newstruct("jmp", "poly h, poly t"); |
---|
272 | } |
---|
273 | example |
---|
274 | { "EXAMPLE:"; echo = 2; |
---|
275 | mod_init(); |
---|
276 | } |
---|
277 | //////////////////////////////////////////////////////////////////// |
---|
278 | proc Terns(list G, int c) |
---|
279 | "USAGE: Terns(G,c); G list, c int |
---|
280 | RETURN: list: T |
---|
281 | NOTE: Input is a list of J-marked polynomials |
---|
282 | (arranged by degree) and an integer. |
---|
283 | EXAMPLE: example Terns; shows an example" |
---|
284 | { |
---|
285 | list T=list(); |
---|
286 | int z; |
---|
287 | for(int k=1; k<=size(G[c]);k=k+1) |
---|
288 | { |
---|
289 | //Loop on G[c] making positions of polynomials in G[c] |
---|
290 | z=size(T); |
---|
291 | T=insert(T,list(1,c,k) ,size(T)); |
---|
292 | } |
---|
293 | return(T); |
---|
294 | } |
---|
295 | example |
---|
296 | { "EXAMPLE:"; echo = 2; |
---|
297 | ring r=0, (x,y,z), rp; |
---|
298 | jmp r1; |
---|
299 | r1.h=z^3; |
---|
300 | r1.t=poly(0); |
---|
301 | jmp r2; |
---|
302 | r2.h=z^2*y; |
---|
303 | r2.t=poly(0); |
---|
304 | jmp r3; |
---|
305 | r3.h=z*y^2 ; |
---|
306 | r3.t=-x^2*y; |
---|
307 | jmp r4; |
---|
308 | r4.h=y^5; |
---|
309 | r4.t=poly(0); |
---|
310 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
311 | Terns(G2F, 1); |
---|
312 | Terns(G2F, 2); |
---|
313 | } |
---|
314 | //////////////////////////////////////////////////////////////////// |
---|
315 | proc VConst(list G, int c) |
---|
316 | "USAGE: VConst(G, c); G list, c int |
---|
317 | RETURN: list: V |
---|
318 | NOTES: this procedure computes the Vm polynomials following the |
---|
319 | algorithm in [CR],but it only keeps in memory the monomials by |
---|
320 | which the G's must be multplied and their positions. |
---|
321 | EXAMPLE: example VConst; shows an example" |
---|
322 | { |
---|
323 | jmp f=G[1][1]; |
---|
324 | int aJ=deg(f.h); |
---|
325 | // minimal degree of polynomials in G |
---|
326 | //print(aJ); |
---|
327 | list V=list(); |
---|
328 | V[1]=Terns(G,1); |
---|
329 | // V[1]=G[1] (keeping in memory only [head, position]) |
---|
330 | //print(c-aJ+1); |
---|
331 | int i; |
---|
332 | int j; |
---|
333 | int m; |
---|
334 | list OO; |
---|
335 | jmp p; |
---|
336 | for(m=2; m<=c-aJ+1; m=m+1) |
---|
337 | { |
---|
338 | //print("entro nel form"); |
---|
339 | if(m>size(G)) |
---|
340 | {V[m]=list(); |
---|
341 | //If we have not G[m] we insert a list() |
---|
342 | //print("vuota prima"); |
---|
343 | } |
---|
344 | else |
---|
345 | {V[m]=Terns(G,m); |
---|
346 | //print("piena prima"); |
---|
347 | } |
---|
348 | for(i=1; i<nvars(basering)+1; i=i+1) |
---|
349 | { |
---|
350 | //print("entrata fori"); |
---|
351 | //print(i); |
---|
352 | for(j=1; j<=size(V[m-1]); j=j+1) |
---|
353 | { |
---|
354 | p=G[V[m-1][j][2]][V[m-1][j][3]]; |
---|
355 | //print(p.h); |
---|
356 | //print(p.t); |
---|
357 | //print(var(i)); |
---|
358 | //print(Minimus(V[m-1][j][1]*p.h)); |
---|
359 | if(var(i)<=Minimus(variables(V[m-1][j][1]*p.h))) |
---|
360 | { |
---|
361 | //Can I multiply by the current variable? |
---|
362 | //print("minoremin"); |
---|
363 | //print("fin qui ci sono"); |
---|
364 | //print(V[m-1][j][1]); |
---|
365 | OO=list(var(i)*V[m-1][j][1],V[m-1][j][2],V[m-1][j][3]); |
---|
366 | V[m]=insert(V[m], OO ,size(V[m])); |
---|
367 | } |
---|
368 | } |
---|
369 | } |
---|
370 | } |
---|
371 | return (V);} |
---|
372 | example |
---|
373 | { "EXAMPLE:"; echo = 2; |
---|
374 | ring r=0, (x,y,z), rp; |
---|
375 | jmp r1; |
---|
376 | r1.h=z^3; |
---|
377 | r1.t=poly(0); |
---|
378 | jmp r2; |
---|
379 | r2.h=z^2*y; |
---|
380 | r2.t=poly(0); |
---|
381 | jmp r3; |
---|
382 | r3.h=z*y^2 ; |
---|
383 | r3.t=-x^2*y; |
---|
384 | jmp r4; |
---|
385 | r4.h=y^5; |
---|
386 | r4.t=poly(0); |
---|
387 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
388 | VConst(G2F,4,basering);} |
---|
389 | //////////////////////////////////////////////////////////////////// |
---|
390 | proc Minimus(ideal L) |
---|
391 | "USAGE: Minimus(L); G list, c int |
---|
392 | RETURN: list: V |
---|
393 | NOTES: it returns the minimal variable generating the ideal L; |
---|
394 | input must be an ideal generated by variables. |
---|
395 | EXAMPLE: example Minimus; shows an example" |
---|
396 | { |
---|
397 | poly min=L[1]; |
---|
398 | int i; |
---|
399 | for(i=2;i<=size(L); i++) |
---|
400 | { |
---|
401 | if(L[i]<min){min=L[i];} |
---|
402 | } |
---|
403 | return(min); |
---|
404 | } |
---|
405 | example |
---|
406 | { "EXAMPLE:"; echo = 2; |
---|
407 | ring r=0, (x,y,z), rp; |
---|
408 | ideal I=y,x,z; |
---|
409 | Minimus(I); |
---|
410 | } |
---|
411 | //////////////////////////////////////////////////////////////////// |
---|
412 | proc Maximus(ideal L) |
---|
413 | "USAGE: Maximus(L); G list, c int |
---|
414 | RETURN: list: V |
---|
415 | NOTES: it returns the maximal variable generating the ideal L |
---|
416 | input must be an ideal generated by variables. |
---|
417 | EXAMPLE: example Maximus; shows an example" |
---|
418 | { |
---|
419 | poly max=L[1]; |
---|
420 | int i; |
---|
421 | for(i=2;i<=size(L); i++) |
---|
422 | { |
---|
423 | if(L[i]>max){max=L[i];} |
---|
424 | } |
---|
425 | return(max); |
---|
426 | } |
---|
427 | example |
---|
428 | { "EXAMPLE:"; echo = 2; |
---|
429 | ring r=0, (x,y,z), rp; |
---|
430 | ideal I=y,x,z; |
---|
431 | Maximus(I); |
---|
432 | } |
---|
433 | //////////////////////////////////////////////////////////////////// |
---|
434 | proc GPolyMin(jmp P, jmp Q) |
---|
435 | "USAGE: GPolyMin(P,Q); P jmp, Q jmp |
---|
436 | RETURN: int: d |
---|
437 | EXAMPLE: example GPolyMin; shows an example" |
---|
438 | { |
---|
439 | int d=1; |
---|
440 | //-1=lower, 0=equal, 1=higher |
---|
441 | //At the beginning suppose Q is higher |
---|
442 | if(deg(P.h)<deg(Q.h)) |
---|
443 | { |
---|
444 | //Compare degrees; |
---|
445 | d=-1; |
---|
446 | //print("Per Grado"); |
---|
447 | } |
---|
448 | if(deg(P.h)==deg(Q.h)) |
---|
449 | { |
---|
450 | if(P.h==Q.h) |
---|
451 | { |
---|
452 | if(P.t==Q.t) |
---|
453 | { |
---|
454 | //head=tail |
---|
455 | d=0; |
---|
456 | //print("Uguali"); |
---|
457 | } |
---|
458 | } |
---|
459 | else |
---|
460 | { |
---|
461 | //print(Minimus(variables(P.h/gcdMon(P.h,Q.h)))); |
---|
462 | //print(Minimus(variables(Q.h/gcdMon(P.h,Q.h)))); |
---|
463 | if(Minimus(variables(P.h/gcdMon(P.h,Q.h)))<Minimus(variables(Q.h/gcdMon(P.h,Q.h)))) |
---|
464 | { |
---|
465 | d=-1; |
---|
466 | //print("Per Indice"); |
---|
467 | } |
---|
468 | } |
---|
469 | } |
---|
470 | return(d); |
---|
471 | } |
---|
472 | example |
---|
473 | { "EXAMPLE:"; echo = 2; |
---|
474 | ring r=0, (x,y,z), rp; |
---|
475 | jmp p1; |
---|
476 | p1.h=poly(1); |
---|
477 | p1.t=poly(1); |
---|
478 | jmp p2; |
---|
479 | p2.h=x^2; |
---|
480 | p2.t=poly(0); |
---|
481 | jmp p3; |
---|
482 | p3.h=x; |
---|
483 | p3.t=poly(0); |
---|
484 | GPolyMin(p1,p2); |
---|
485 | GPolyMin(p2, p3); |
---|
486 | GPolyMin(p2,p2); |
---|
487 | } |
---|
488 | //////////////////////////////////////////////////////////////////// |
---|
489 | proc TernComparer(list A, list B, list G) |
---|
490 | "USAGE: TernComparer(A,B,C); A list, B list, G list |
---|
491 | RETURN: int: d |
---|
492 | NOTE: A and B are terns, while G is the given list of |
---|
493 | J-marked polynomials. |
---|
494 | EXAMPLE: example TernComparer; shows an example" |
---|
495 | { |
---|
496 | int d=-1; |
---|
497 | //Start: A<B |
---|
498 | if(A[1]==B[1]) |
---|
499 | { |
---|
500 | if(A[2]==B[2]&& A[3]==B[3]) |
---|
501 | { |
---|
502 | //print("Uguali"); |
---|
503 | d=0; |
---|
504 | } |
---|
505 | else |
---|
506 | { |
---|
507 | jmp g1=G[A[2]][A[3]]; |
---|
508 | jmp g2=G[B[2]][B[3]]; |
---|
509 | if(GPolyMin(g1, g2)==1) |
---|
510 | { |
---|
511 | //print("Maggiore per il G"); |
---|
512 | d=1; |
---|
513 | } |
---|
514 | } |
---|
515 | } |
---|
516 | else |
---|
517 | { |
---|
518 | if(A[1]>B[1]) |
---|
519 | { |
---|
520 | //the ordering MUST be rp |
---|
521 | //print("Maggiore per Lex"); |
---|
522 | d=1; |
---|
523 | } |
---|
524 | } |
---|
525 | return(d); |
---|
526 | } |
---|
527 | example |
---|
528 | { "EXAMPLE:"; echo = 2; |
---|
529 | ring r=0, (x,y,z), rp; |
---|
530 | jmp r1; |
---|
531 | r1.h=z^3; |
---|
532 | r1.t=poly(0); |
---|
533 | jmp r2; |
---|
534 | r2.h=z^2*y; |
---|
535 | r2.t=poly(0); |
---|
536 | jmp r3; |
---|
537 | r3.h=z*y^2 ; |
---|
538 | r3.t=-x^2*y; |
---|
539 | jmp r4; |
---|
540 | r4.h=y^5; |
---|
541 | r4.t=poly(0); |
---|
542 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
543 | TernComparer([1,1,1],[x,1,1],G2F); |
---|
544 | } |
---|
545 | //////////////////////////////////////////////////////////////////// |
---|
546 | proc MinimalV(list V, list G) |
---|
547 | "USAGE: Minimal(V,G); V list, G list |
---|
548 | RETURN: int: R |
---|
549 | NOTE: Input=list(terns), G. |
---|
550 | EXAMPLE: example MinimalV; shows an example" |
---|
551 | { |
---|
552 | //Minimal element for a given degree |
---|
553 | list R=list(); |
---|
554 | list MIN=V[1]; |
---|
555 | int h=1; |
---|
556 | int i; |
---|
557 | for(i=2; i<=size(V); i++) |
---|
558 | { |
---|
559 | //I consider the first as minimum |
---|
560 | //If I find something smaller I change minimum |
---|
561 | if(TernComparer(V[i],MIN,G)<=0) |
---|
562 | { |
---|
563 | MIN=V[i]; |
---|
564 | h=i; |
---|
565 | } |
---|
566 | } |
---|
567 | //Return: [minimum,position of the minimum] |
---|
568 | R=MIN,h; |
---|
569 | return(R); |
---|
570 | } |
---|
571 | example |
---|
572 | { "EXAMPLE:"; echo = 2; |
---|
573 | ring r=0, (x,y,z), rp; |
---|
574 | jmp r1; |
---|
575 | r1.h=z^3; |
---|
576 | r1.t=poly(0); |
---|
577 | jmp r2; |
---|
578 | r2.h=z^2*y; |
---|
579 | r2.t=poly(0); |
---|
580 | jmp r3; |
---|
581 | r3.h=z*y^2 ; |
---|
582 | r3.t=-x^2*y; |
---|
583 | jmp r4; |
---|
584 | r4.h=y^5; |
---|
585 | r4.t=poly(0); |
---|
586 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
587 | MinimalV(VConst(G2F,4,basering)[1],G2F); |
---|
588 | } |
---|
589 | //////////////////////////////////////////////////////////////////// |
---|
590 | proc OrderV(list V,list G,list R) |
---|
591 | "USAGE: Ordinare(V,G,R); V list, G list, R list |
---|
592 | RETURN: list: R |
---|
593 | NOTE: Input: Vm,G,emptylist |
---|
594 | EXAMPLE: example Ordinare; shows an example" |
---|
595 | { |
---|
596 | //Order V[m] |
---|
597 | //R will contain results but at the beginning it is empty |
---|
598 | list M=list(); |
---|
599 | if(size(V)==1) |
---|
600 | { |
---|
601 | R=insert(R,V[1],size(R)); |
---|
602 | } |
---|
603 | else |
---|
604 | { |
---|
605 | M=MinimalV(V,G); |
---|
606 | R=insert(R,M[1],size(R)); |
---|
607 | V=delete(V,M[2]); |
---|
608 | //recursive call |
---|
609 | R=OrderV(V,G,R); |
---|
610 | } |
---|
611 | return(R); |
---|
612 | } |
---|
613 | example |
---|
614 | { "EXAMPLE:"; echo = 2; |
---|
615 | ring r=0, (x,y,z), rp; |
---|
616 | jmp r1; |
---|
617 | r1.h=z^3; |
---|
618 | r1.t=poly(0); |
---|
619 | jmp r2; |
---|
620 | r2.h=z^2*y; |
---|
621 | r2.t=poly(0); |
---|
622 | jmp r3; |
---|
623 | r3.h=z*y^2; |
---|
624 | r3.t=-x^2*y; |
---|
625 | jmp r4; |
---|
626 | r4.h=y^5; |
---|
627 | r4.t=poly(0); |
---|
628 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
629 | OrderV(VConst(G2F,4,r)[1],G2F,list()); |
---|
630 | } |
---|
631 | //////////////////////////////////////////////////////////////////// |
---|
632 | proc StartOrderingV(list V,list G) |
---|
633 | "USAGE: StartOrderingV(V,G); V list, G list |
---|
634 | RETURN: list: R |
---|
635 | NOTE: Input Vm,G. This procedure uses OrderV to get |
---|
636 | the ordered polynomials as in [BCLR]. |
---|
637 | EXAMPLE: example StartOrderingV; shows an example" |
---|
638 | { |
---|
639 | return(OrderV(V,G, list())); |
---|
640 | } |
---|
641 | example |
---|
642 | { "EXAMPLE:"; echo = 2; |
---|
643 | ring r=0, (x,y,z), rp; |
---|
644 | jmp r1; |
---|
645 | r1.h=z^3; |
---|
646 | r1.t=poly(0); |
---|
647 | jmp r2; |
---|
648 | r2.h=z^2*y; |
---|
649 | r2.t=poly(0); |
---|
650 | jmp r3; |
---|
651 | r3.h=z*y^2; |
---|
652 | r3.t=-x^2*y; |
---|
653 | jmp r4; |
---|
654 | r4.h=y^5; |
---|
655 | r4.t=poly(0); |
---|
656 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
657 | StartOrderingV(VConst(G2F,4,basering)[1],G2F); |
---|
658 | } |
---|
659 | //////////////////////////////////////////////////////////////////// |
---|
660 | proc MultiplyJmP(list L, list G) |
---|
661 | "USAGE: MultiplyJmP(L,G); L list, G list |
---|
662 | RETURN: jmp: K |
---|
663 | NOTE: Input: a 3-ple,G. It performs the product associated |
---|
664 | to the 3-uple. |
---|
665 | EXAMPLE: example MultiplyJmP; shows an example" |
---|
666 | { |
---|
667 | jmp g=G[L[2]][L[3]]; |
---|
668 | jmp K; |
---|
669 | K.h=L[1]*g.h; |
---|
670 | K.t=L[1]*g.t; |
---|
671 | return(K); |
---|
672 | } |
---|
673 | example |
---|
674 | { "EXAMPLE:"; echo = 2; |
---|
675 | ring r=0, (x,y,z), rp; |
---|
676 | list P=x^2,1,1; |
---|
677 | jmp r1; |
---|
678 | r1.h=z^3; |
---|
679 | r1.t=poly(0); |
---|
680 | jmp r2; |
---|
681 | r2.h=z^2*y; |
---|
682 | r2.t=poly(0); |
---|
683 | jmp r3; |
---|
684 | r3.h=z*y^2 ; |
---|
685 | r3.t=-x^2*y; |
---|
686 | jmp r4; |
---|
687 | r4.h=y^5; |
---|
688 | r4.t=poly(0); |
---|
689 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
690 | MultiplyJmP(P,G2F); |
---|
691 | } |
---|
692 | //////////////////////////////////////////////////////////////////// |
---|
693 | //proc JmpIdeal(list V,r) |
---|
694 | //"USAGE: JmpIdeal(V); V list |
---|
695 | //RETURN: ideal: I |
---|
696 | //NOTES: this procedure takes a list of Vm's of a certain degree |
---|
697 | //and construct their ideal, multiplying the head by the weighted |
---|
698 | //variable t. |
---|
699 | //EXAMPLE: example JmpIdeal; shows an example" |
---|
700 | //{ |
---|
701 | //ideal I=0; |
---|
702 | //int i; |
---|
703 | //if (size(V)!=0) |
---|
704 | // { |
---|
705 | // list M=list(); |
---|
706 | //jmp g; |
---|
707 | // for(i=1; i<= size(V); i++) |
---|
708 | // { |
---|
709 | // g=V[i]; |
---|
710 | // g.h=(g.h)*t; |
---|
711 | // M[i]=g.h+g.t; |
---|
712 | // } |
---|
713 | // I=M[1..size(M)]; |
---|
714 | //attrib(I,"isSB",1); |
---|
715 | // } |
---|
716 | //return(I); |
---|
717 | //} |
---|
718 | //example |
---|
719 | //{ "EXAMPLE:"; echo = 2; |
---|
720 | // ring r=0, (x,y,z,t), rp; |
---|
721 | //jmp r1; |
---|
722 | //r1.h=z^3; |
---|
723 | //r1.t=poly(0); |
---|
724 | //jmp r2; |
---|
725 | //r2.h=z^2*y; |
---|
726 | //r2.t=poly(0); |
---|
727 | //jmp r3; |
---|
728 | //r3.h=z*y^2 ; |
---|
729 | //r3.t=-x^2*y; |
---|
730 | //jmp r4; |
---|
731 | //r4.h=y^5; |
---|
732 | //r4.t=poly(0); |
---|
733 | //list G2F=list(list(r1,r2,r3),list(r4)); |
---|
734 | //JmpIdeal(VConst(G2F,6,r)[1],r); |
---|
735 | //} |
---|
736 | //////////////////////////////////////////////////////////////////// |
---|
737 | proc NewWeight(int n) |
---|
738 | "USAGE: NewWeight(n); n int |
---|
739 | RETURN: intvec: u |
---|
740 | EXAMPLE: example NewWeight; shows an example" |
---|
741 | { |
---|
742 | intvec u=0; |
---|
743 | u[n]=1; |
---|
744 | return(u); |
---|
745 | } |
---|
746 | example |
---|
747 | { "EXAMPLE:"; echo = 2; |
---|
748 | NewWeight(3); |
---|
749 | } |
---|
750 | //////////////////////////////////////////////////////////////////// |
---|
751 | proc FinalVm(list V1 , list G1 , def r) |
---|
752 | "USAGE: FinalVm(V1, G1, r); V1 list, G1 list , r |
---|
753 | RETURN: intvec: u |
---|
754 | EXAMPLE: example FinalVm; shows an example" |
---|
755 | { |
---|
756 | //multiply and reduce, degree by degree |
---|
757 | intvec u=NewWeight(nvars(r)+1); |
---|
758 | list L=ringlist(r); |
---|
759 | L[2]=insert(L[2],"t",size(L[2])); |
---|
760 | //print(L[2]); |
---|
761 | list ordlist="a",u; |
---|
762 | L[3]=insert(L[3],ordlist,0); |
---|
763 | def H=ring(L); |
---|
764 | //print(V1); |
---|
765 | //print(G1); |
---|
766 | list M=list(); |
---|
767 | jmp p; |
---|
768 | list N; |
---|
769 | poly q; |
---|
770 | poly s; |
---|
771 | int i; |
---|
772 | int j; |
---|
773 | for(i=1; i<=size(G1); i++) |
---|
774 | { |
---|
775 | N=list(); |
---|
776 | for(j=1; j<=size(G1[i]); j++) |
---|
777 | { |
---|
778 | p=G1[i][j]; |
---|
779 | q=p.h; |
---|
780 | s=p.t; |
---|
781 | N[j]=list(q,s); |
---|
782 | } |
---|
783 | M[i]=N; |
---|
784 | } |
---|
785 | //print("M is"); |
---|
786 | //print(M); |
---|
787 | p.h=poly(0); |
---|
788 | p.t=poly(0); |
---|
789 | setring H; |
---|
790 | list R=list(); |
---|
791 | list S=list(); |
---|
792 | //print("anello definito"); |
---|
793 | list V=imap(r,V1); |
---|
794 | //def G=imap(r,G1); |
---|
795 | //print(V); |
---|
796 | list MM=imap(r,M); |
---|
797 | list G=list(); |
---|
798 | list N=list(); |
---|
799 | for(i=1; i<=size(MM); i++) |
---|
800 | { |
---|
801 | for(j=1; j<=size(MM[i]); j++) |
---|
802 | { |
---|
803 | p.h=MM[i][j][1]; |
---|
804 | p.t=MM[i][j][2]; |
---|
805 | N[j]=p; |
---|
806 | } |
---|
807 | G[i]=N; |
---|
808 | } |
---|
809 | ideal I=0; |
---|
810 | jmp LL; |
---|
811 | jmp UU; |
---|
812 | //print("pronta x ridurre"); |
---|
813 | for(i=1; i<=size(V);i++) |
---|
814 | { |
---|
815 | //print("sono a V di"); |
---|
816 | //print(i); |
---|
817 | R[i]=list(); |
---|
818 | S[i]=list(); |
---|
819 | I=0; |
---|
820 | attrib(I,"isSB",1); |
---|
821 | for(j=1;j<=size(V[i]); j++) |
---|
822 | { |
---|
823 | //print(j); |
---|
824 | //print("esimo elem"); |
---|
825 | LL=MultiplyJmP(V[i][j],G); |
---|
826 | LL.t=reduce(t*LL.t,I); |
---|
827 | //I only reduce the tail |
---|
828 | //print(LL.t); |
---|
829 | LL.t=subst(LL.t,t,1); |
---|
830 | S[i]=insert(S[i],LL,size(S[i])); |
---|
831 | LL.h=t*LL.h; |
---|
832 | R[i]=insert(R[i],LL,size(R[i])); |
---|
833 | UU=R[i][j]; |
---|
834 | I=I+ideal(UU.h+UU.t); |
---|
835 | attrib(I,"isSB",1); |
---|
836 | } |
---|
837 | } |
---|
838 | //print("ho ridotto"); |
---|
839 | list M=list(); |
---|
840 | poly q; |
---|
841 | poly s; |
---|
842 | for(i=1; i<=size(S); i++) |
---|
843 | { |
---|
844 | N=list(); |
---|
845 | for(j=1; j<=size(S[i]); j++) |
---|
846 | { |
---|
847 | p=S[i][j]; |
---|
848 | q=p.h; |
---|
849 | s=p.t; |
---|
850 | N[j]=list(q,s); |
---|
851 | } |
---|
852 | M[i]=N; |
---|
853 | } |
---|
854 | p.h=poly(0); |
---|
855 | p.t=poly(0); |
---|
856 | setring r; |
---|
857 | def MM=imap(H,M); |
---|
858 | list MMM=list(); |
---|
859 | for(i=1; i<=size(MM); i++) |
---|
860 | { |
---|
861 | N=list(); |
---|
862 | for(j=1; j<=size(MM[i]); j++) |
---|
863 | { |
---|
864 | p.h=MM[i][j][1]; |
---|
865 | p.t=MM[i][j][2]; |
---|
866 | N[j]=p; |
---|
867 | } |
---|
868 | MMM[i]=N; |
---|
869 | } |
---|
870 | return(MMM); |
---|
871 | } |
---|
872 | example |
---|
873 | { "EXAMPLE:"; echo = 2; |
---|
874 | ring r=0, (x,y,z), rp; |
---|
875 | jmp r1; |
---|
876 | r1.h=z^3; |
---|
877 | r1.t=poly(0); |
---|
878 | jmp r2; |
---|
879 | r2.h=z^2*y; |
---|
880 | r2.t=poly(0); |
---|
881 | jmp r3; |
---|
882 | r3.h=z*y^2 ; |
---|
883 | r3.t=-x^2*y; |
---|
884 | jmp r4; |
---|
885 | r4.h=y^5; |
---|
886 | r4.t=poly(0); |
---|
887 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
888 | FinalVm(VConst(G2F,6,r) , G2F, r); |
---|
889 | } |
---|
890 | //////////////////////////////////////////////////////////////////// |
---|
891 | proc VmConstructor(list G, int c,def r) |
---|
892 | "USAGE: VmConstructor(G,c); G list, c int |
---|
893 | RETURN: list: R |
---|
894 | NOTE: At the end separated by degree. |
---|
895 | EXAMPLE: example VmConstructor; shows an example" |
---|
896 | { |
---|
897 | list V=list(); |
---|
898 | V= VConst(G,c); |
---|
899 | //print("VConst"); |
---|
900 | //V non ordered |
---|
901 | list L=list(); |
---|
902 | list R=list(); |
---|
903 | int i; |
---|
904 | // head, position |
---|
905 | //order the different degrees |
---|
906 | for(i=1; i<=size(V); i++) |
---|
907 | { |
---|
908 | L[i]=StartOrderingV(V[i], G); |
---|
909 | } |
---|
910 | //print("finito ordine"); |
---|
911 | //multiply and reduce |
---|
912 | //print("Ordinare"); |
---|
913 | //R=FinalVm(L, G, r); |
---|
914 | //print("FinalVm"); |
---|
915 | return(L); |
---|
916 | } |
---|
917 | example |
---|
918 | { "EXAMPLE:"; echo = 2; |
---|
919 | ring r=0, (x,y,z), rp; |
---|
920 | jmp r1; |
---|
921 | r1.h=z^3; |
---|
922 | r1.t=poly(0); |
---|
923 | jmp r2; |
---|
924 | r2.h=z^2*y; |
---|
925 | r2.t=poly(0); |
---|
926 | jmp r3; |
---|
927 | r3.h=z*y^2 ; |
---|
928 | r3.t=-x^2*y; |
---|
929 | jmp r4; |
---|
930 | r4.h=y^5; |
---|
931 | r4.t=poly(0); |
---|
932 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
933 | VmConstructor(G2F,6,r); |
---|
934 | } |
---|
935 | //////////////////////////////////////////////////////////////////// |
---|
936 | proc EKCouples(jmp A, jmp B) |
---|
937 | "USAGE: CoppiaEK(A,B); A list, B list |
---|
938 | RETURN: list: L |
---|
939 | NOTE: At the end the monomials involved by EK. |
---|
940 | EXAMPLE: example EKCouples; shows an example" |
---|
941 | { |
---|
942 | poly E; |
---|
943 | list L=0,0; |
---|
944 | string s=varstr(basering); |
---|
945 | list VVV=varstr(basering); |
---|
946 | //L will contain results |
---|
947 | poly h=Minimus(variables(A.h)); |
---|
948 | //print(h); |
---|
949 | int l=findvars(h)[2][1]; |
---|
950 | if(l!=nvars(basering)) |
---|
951 | { |
---|
952 | //print("vero"); |
---|
953 | //print(l); |
---|
954 | for(int j=l+1;j<=nvars(basering); j++) |
---|
955 | { |
---|
956 | //print("entrata"); |
---|
957 | //print(var(j)); |
---|
958 | E=var(j)*A.h/B.h; |
---|
959 | //Candidate for * product |
---|
960 | //print(E); |
---|
961 | if(E!=0) |
---|
962 | { |
---|
963 | //print("primo if passato"); |
---|
964 | if(Minimus(variables(B.h))>=Maximus(variables(E))) |
---|
965 | { |
---|
966 | //Does it work with * ? |
---|
967 | //print("secondo if passato"); |
---|
968 | L[1]=j; |
---|
969 | L[2]=E; |
---|
970 | break; |
---|
971 | } |
---|
972 | } |
---|
973 | } |
---|
974 | } |
---|
975 | return (L); |
---|
976 | } |
---|
977 | example |
---|
978 | { "EXAMPLE:"; echo = 2; |
---|
979 | ring r=0, (x,y,z), rp; |
---|
980 | jmp A; |
---|
981 | A.h=y*z^2; |
---|
982 | A.t=poly(0); |
---|
983 | jmp B; |
---|
984 | B.h=y^2*z; |
---|
985 | B.t=poly(0); |
---|
986 | EKCouples(A,B); |
---|
987 | EKCouples(B,A); |
---|
988 | } |
---|
989 | //////////////////////////////////////////////////////////////////// |
---|
990 | proc EKPolynomials(list G) |
---|
991 | "USAGE: EKPolynomials(G); G list |
---|
992 | RETURN: list: EK, list: D |
---|
993 | NOTE: At the end EK polynomials and their degrees |
---|
994 | |
---|
995 | EXAMPLE: example EKPolynomials; shows an example" |
---|
996 | { |
---|
997 | list D=list(); |
---|
998 | list C=list(); |
---|
999 | list N=0,0; |
---|
1000 | list EK=list(); |
---|
1001 | int i; |
---|
1002 | int j; |
---|
1003 | int k; |
---|
1004 | int l; |
---|
1005 | jmp p; |
---|
1006 | for(i=1; i<=size(G); i++) |
---|
1007 | { |
---|
1008 | for(j=1; j<=size(G[i]); j++) |
---|
1009 | { |
---|
1010 | for(k=1; k<=size(G); k++) |
---|
1011 | { |
---|
1012 | for(l=1; l<=size(G[k]); l++) |
---|
1013 | { |
---|
1014 | if(i!=k||j!=l) |
---|
1015 | { |
---|
1016 | //Loop on polynomials |
---|
1017 | C=EKCouples(G[i][j], G[k][l]); |
---|
1018 | //print("coppia"); |
---|
1019 | if(C[2]!=0) |
---|
1020 | { |
---|
1021 | C=insert(C,list(i,j,k,l),size(C)); |
---|
1022 | EK=insert(EK,C,size(EK)); |
---|
1023 | p=G[k][l]; |
---|
1024 | D=insert(D,deg(C[2]*p.h),size(D)); |
---|
1025 | } |
---|
1026 | } |
---|
1027 | } |
---|
1028 | } |
---|
1029 | } |
---|
1030 | } |
---|
1031 | //Double Return |
---|
1032 | return(EK, D); |
---|
1033 | } |
---|
1034 | example |
---|
1035 | { "EXAMPLE:"; echo = 2; |
---|
1036 | ring r=0, (x,y,z), rp; |
---|
1037 | jmp r1; |
---|
1038 | r1.h=z^3; |
---|
1039 | r1.t=poly(0); |
---|
1040 | jmp r2; |
---|
1041 | r2.h=z^2*y; |
---|
1042 | r2.t=poly(0); |
---|
1043 | jmp r3; |
---|
1044 | r3.h=z*y^2; |
---|
1045 | r3.t=-x^2*y; |
---|
1046 | jmp r4; |
---|
1047 | r4.h=y^5; |
---|
1048 | r4.t=poly(0); |
---|
1049 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
1050 | EKPolynomials(G2F); |
---|
1051 | } |
---|
1052 | //////////////////////////////////////////////////////////////////// |
---|
1053 | proc MultEKPolys(list EK, list G) |
---|
1054 | "USAGE: MultEKPolys(G); G list |
---|
1055 | RETURN: list: p |
---|
1056 | NOTE: At the end I obtain the EK polynomials and |
---|
1057 | their degrees. |
---|
1058 | EXAMPLE: example MultEKPolys; shows an example" |
---|
1059 | { |
---|
1060 | jmp u; |
---|
1061 | u=G[EK[3][1]][EK[3][2]]; |
---|
1062 | //print("u"); |
---|
1063 | jmp q; |
---|
1064 | q=G[EK[3][3]][EK[3][4]]; |
---|
1065 | return(var(EK[1])*(u.h+u.t)-EK[2]*(q.h+q.t)); |
---|
1066 | } |
---|
1067 | example |
---|
1068 | { "EXAMPLE:"; echo = 2; |
---|
1069 | ring r=0, (x,y,z), rp; |
---|
1070 | jmp r1; |
---|
1071 | r1.h=z^3; |
---|
1072 | r1.t=poly(0); |
---|
1073 | jmp r2; |
---|
1074 | r2.h=z^2*y; |
---|
1075 | r2.t=poly(0); |
---|
1076 | jmp r3; |
---|
1077 | r3.h=z*y^2; |
---|
1078 | r3.t=-x^2*y; |
---|
1079 | jmp r4; |
---|
1080 | r4.h=y^5; |
---|
1081 | r4.t=poly(0); |
---|
1082 | list G2F=list(list(r1,r2,r3),list(r4)); |
---|
1083 | list EK,D=EKPolynomials(G2F); |
---|
1084 | MultEKPolys(EK[2],G2F); |
---|
1085 | } |
---|
1086 | //////////////////////////////////////////////////////////////////// |
---|
1087 | proc SchemeEq(list W, list EK,list D,list Q,def r) |
---|
1088 | "USAGE: SchemeEq(W,EK,D,Q,r); W list, EK list, D list, Q list, r ring |
---|
1089 | RETURN: int: i |
---|
1090 | NOTE: |
---|
1091 | This procedure performs the reduction of EK-polynomials, obtaining |
---|
1092 | the J-marked scheme. |
---|
1093 | EXAMPLE: example SchemeEq; shows an example" |
---|
1094 | { |
---|
1095 | list Jms=list(); |
---|
1096 | //ideal I; |
---|
1097 | list M=list(); |
---|
1098 | jmp mini; |
---|
1099 | mini=W[1][1]; |
---|
1100 | int minimo=deg(mini.h); |
---|
1101 | //multiply variables |
---|
1102 | poly pd=poly(1); |
---|
1103 | for(int i=1;i<=nvars(r);i++) |
---|
1104 | {pd=pd*var(i);} |
---|
1105 | //CHANGE RING |
---|
1106 | intvec u=NewWeight(nvars(r)+1); |
---|
1107 | list L=ringlist(r); |
---|
1108 | L[2]=insert(L[2],"t",size(L[2])); |
---|
1109 | //print(L[2]); |
---|
1110 | list ordlist="a",u; |
---|
1111 | L[3]=insert(L[3],ordlist,0); |
---|
1112 | def H=ring(L); |
---|
1113 | //list |
---|
1114 | M=list(); |
---|
1115 | jmp pu; |
---|
1116 | list N; |
---|
1117 | poly q; |
---|
1118 | poly s; |
---|
1119 | i=0; |
---|
1120 | int j; |
---|
1121 | for(i=1; i<=size(Q); i++) |
---|
1122 | { |
---|
1123 | N=list(); |
---|
1124 | for(j=1; j<=size(Q[i]); j++) |
---|
1125 | { |
---|
1126 | pu=Q[i][j]; |
---|
1127 | q=pu.h; |
---|
1128 | s=pu.t; |
---|
1129 | N[j]=list(q,s); |
---|
1130 | } |
---|
1131 | M[i]=N; |
---|
1132 | } |
---|
1133 | list O; |
---|
1134 | pu.h=poly(0); |
---|
1135 | pu.t=poly(0); |
---|
1136 | for(i=1; i<=size(W); i++) |
---|
1137 | { |
---|
1138 | N=list(); |
---|
1139 | for(j=1; j<=size(W[i]); j++) |
---|
1140 | { |
---|
1141 | pu=W[i][j]; |
---|
1142 | q=pu.h; |
---|
1143 | s=pu.t; |
---|
1144 | N[j]=list(q,s); |
---|
1145 | } |
---|
1146 | O[i]=N; |
---|
1147 | } |
---|
1148 | pu.h=poly(0); |
---|
1149 | pu.t=poly(0); |
---|
1150 | setring H; |
---|
1151 | list R=list(); |
---|
1152 | list S=list(); |
---|
1153 | //print("anello definito"); |
---|
1154 | def EK=imap(r,EK); |
---|
1155 | def MM=imap(r,M); |
---|
1156 | def OO=imap(r,O); |
---|
1157 | def pd=imap(r,pd); |
---|
1158 | list G=list(); |
---|
1159 | list N=list(); |
---|
1160 | for(i=1; i<=size(MM); i++) |
---|
1161 | { |
---|
1162 | for(j=1; j<=size(MM[i]); j++) |
---|
1163 | { |
---|
1164 | pu.h=MM[i][j][1]; |
---|
1165 | pu.t=MM[i][j][2]; |
---|
1166 | N[j]=pu; |
---|
1167 | } |
---|
1168 | G[i]=N; |
---|
1169 | } |
---|
1170 | list V; |
---|
1171 | for(i=1; i<=size(OO); i++) |
---|
1172 | { |
---|
1173 | for(j=1; j<=size(OO[i]); j++) |
---|
1174 | { |
---|
1175 | pu.h=OO[i][j][1]; |
---|
1176 | pu.t=OO[i][j][2]; |
---|
1177 | N[j]=pu; |
---|
1178 | } |
---|
1179 | V[i]=N; |
---|
1180 | } |
---|
1181 | //print(V); |
---|
1182 | //print(G); |
---|
1183 | matrix C; |
---|
1184 | list COEFF; |
---|
1185 | poly p=0; |
---|
1186 | poly q=0; |
---|
1187 | ideal I; |
---|
1188 | list M; |
---|
1189 | i=0; |
---|
1190 | jmp g; |
---|
1191 | int k; |
---|
1192 | for(j=1; j<=size(EK);j++) |
---|
1193 | { |
---|
1194 | //print("arrivo"); |
---|
1195 | //print(j); |
---|
1196 | p=MultEKPolys(EK[j],G); |
---|
1197 | //ideal |
---|
1198 | I=0; |
---|
1199 | if (size(V[D[j]-minimo+1])!=0) |
---|
1200 | { |
---|
1201 | M=list(); |
---|
1202 | // jmp g; |
---|
1203 | for(i=1; i<= size(V[D[j]-minimo+1]); i++) |
---|
1204 | { |
---|
1205 | g=V[D[j]-minimo+1][i]; |
---|
1206 | g.h=(g.h)*t; |
---|
1207 | M[i]=g.h+g.t; |
---|
1208 | } |
---|
1209 | I=M[1..size(M)]; |
---|
1210 | attrib(I,"isSB",1); |
---|
1211 | //print(I); |
---|
1212 | } |
---|
1213 | //print(I); |
---|
1214 | q=reduce(t*p,I); |
---|
1215 | q=subst(q,t,1); |
---|
1216 | C=coef(q,pd); |
---|
1217 | COEFF=C[2,1..ncols(C)]; |
---|
1218 | for(k=1;k<=size(COEFF);k++) |
---|
1219 | { |
---|
1220 | if(COEFF[k]!=0) |
---|
1221 | { Jms=insert(Jms,COEFF[k],size(Jms));} |
---|
1222 | } |
---|
1223 | } |
---|
1224 | setring r; |
---|
1225 | def Jms=imap(H,Jms); |
---|
1226 | return(Jms); |
---|
1227 | } |
---|
1228 | example |
---|
1229 | { "EXAMPLE:"; echo = 2; |
---|
1230 | ring r=0, (x,y,z),rp; |
---|
1231 | ideal Borid=y^2*z,y*z^2,z^3,y^5; |
---|
1232 | attrib(Borid,"isSB",1); |
---|
1233 | list B=ArrangeBorel(Borid); |
---|
1234 | list NumN; |
---|
1235 | list N; |
---|
1236 | int i; |
---|
1237 | int d; |
---|
1238 | for(i=1;i<=size(B);i++) |
---|
1239 | { |
---|
1240 | d=deg(B[i][1]); |
---|
1241 | N[i]=kbase(Borid,d); |
---|
1242 | NumN[i]=size(N[i]); |
---|
1243 | } |
---|
1244 | int qc=NumNewVar(B, NumN); |
---|
1245 | //Now I must define the NEW RING, |
---|
1246 | //putting the c parameters inside. |
---|
1247 | list L=ringlist(r); |
---|
1248 | list L2; |
---|
1249 | L2[1]=L[1]; |
---|
1250 | L2[2]=list(); |
---|
1251 | for(i=qc;i>=1;i--) |
---|
1252 | { |
---|
1253 | L2[2][i]="c("+string(i)+")"; |
---|
1254 | } |
---|
1255 | L2[3]=list(list("rp",qc)); |
---|
1256 | L2[4]=L[4]; |
---|
1257 | L[1]=L2; |
---|
1258 | if(defined(K)){kill K;} |
---|
1259 | def K=ring(L); |
---|
1260 | export K; |
---|
1261 | setring(K); |
---|
1262 | def Borid=imap(r,Borid); |
---|
1263 | def N=imap(r,N); |
---|
1264 | def B=imap(r,B); |
---|
1265 | //NumN contains only scalars so I do not imap it |
---|
1266 | int j; |
---|
1267 | list Q; |
---|
1268 | int s; |
---|
1269 | list M; |
---|
1270 | jmp pp; |
---|
1271 | for(i=1;i<=size(B);i++) |
---|
1272 | { |
---|
1273 | Q[i]=list(); |
---|
1274 | for(j=1;j<=size(B[i]);j++) |
---|
1275 | { |
---|
1276 | M=NewTails(N[i],s); |
---|
1277 | pp.h=B[i][j]; |
---|
1278 | pp.t=M[1]; |
---|
1279 | Q[i][j]=pp; |
---|
1280 | s=s+M[2]; |
---|
1281 | //print(s); |
---|
1282 | } |
---|
1283 | } |
---|
1284 | list P=ArrangeTails(Q); |
---|
1285 | list EK,D= EKPolynomials(P); |
---|
1286 | int massimo=Max(D); |
---|
1287 | //list V=VConst(P, massimo); |
---|
1288 | //pause(); |
---|
1289 | list V=VmConstructor(P,massimo,r); |
---|
1290 | list W=FinalVm(V,P,K); |
---|
1291 | //print("I V ridotti in ordine sono"); |
---|
1292 | //print(W); |
---|
1293 | list Jms=SchemeEq(W,EK,D,P,K); |
---|
1294 | Jms;} |
---|
1295 | |
---|
1296 | ////////////////////////////////////////////////////////////////////// |
---|
1297 | proc JMarkedScheme(ideal Borid,def r) |
---|
1298 | "USAGE: JMarkedScheme(Borid, r); Borid ideal, r ring |
---|
1299 | RETURN: list: Jms |
---|
1300 | NOTE: |
---|
1301 | This procedure performs automatically the whole construction |
---|
1302 | of the J-marked scheme. |
---|
1303 | EXAMPLE: example JMarkedScheme; shows an example" |
---|
1304 | { |
---|
1305 | list Jms; |
---|
1306 | if(BorelCheck(Borid,r)) |
---|
1307 | { |
---|
1308 | if(size(Borid)==1) |
---|
1309 | { Jms=list();} |
---|
1310 | else{ |
---|
1311 | //print("Input is OK"); |
---|
1312 | attrib(Borid,"isSB",1); |
---|
1313 | list B=ArrangeBorel(Borid); |
---|
1314 | list NumN; |
---|
1315 | list N; |
---|
1316 | int i; |
---|
1317 | int d; |
---|
1318 | for(i=1;i<=size(B);i++) |
---|
1319 | { |
---|
1320 | d=deg(B[i][1]); |
---|
1321 | N[i]=kbase(Borid,d); |
---|
1322 | NumN[i]=size(N[i]); |
---|
1323 | } |
---|
1324 | int qc=NumNewVar(B, NumN); |
---|
1325 | if(qc==0) |
---|
1326 | {Jms=list(0);} |
---|
1327 | else |
---|
1328 | { |
---|
1329 | //Now I must define the NEW RING, |
---|
1330 | //putting the c parameters inside. |
---|
1331 | list L=ringlist(r); |
---|
1332 | list L2; |
---|
1333 | L2[1]=L[1]; |
---|
1334 | L2[2]=list(); |
---|
1335 | for(i=qc;i>=1;i--) |
---|
1336 | { |
---|
1337 | L2[2][i]="c("+string(i)+")"; |
---|
1338 | } |
---|
1339 | L2[3]=list(list("rp",qc)); |
---|
1340 | L2[4]=L[4]; |
---|
1341 | L[1]=L2; |
---|
1342 | if(defined(K)){kill K;} |
---|
1343 | def K=ring(L); |
---|
1344 | export K; |
---|
1345 | setring(K); |
---|
1346 | def Borid=imap(r,Borid); |
---|
1347 | def N=imap(r,N); |
---|
1348 | def B=imap(r,B); |
---|
1349 | //NumN contains only scalars so I do not imap it |
---|
1350 | int j; |
---|
1351 | list Q; |
---|
1352 | int s; |
---|
1353 | list M; |
---|
1354 | jmp pp; |
---|
1355 | for(i=1;i<=size(B);i++) |
---|
1356 | { |
---|
1357 | Q[i]=list(); |
---|
1358 | for(j=1;j<=size(B[i]);j++) |
---|
1359 | { |
---|
1360 | M=NewTails(N[i],s); |
---|
1361 | pp.h=B[i][j]; |
---|
1362 | pp.t=M[1]; |
---|
1363 | Q[i][j]=pp; |
---|
1364 | s=s+M[2]; |
---|
1365 | //print(s); |
---|
1366 | } |
---|
1367 | } |
---|
1368 | list P=ArrangeTails(Q); |
---|
1369 | list EK,D= EKPolynomials(P); |
---|
1370 | int massimo=Max(D); |
---|
1371 | //list V=VConst(P, massimo); |
---|
1372 | //pause(); |
---|
1373 | list V=VmConstructor(P,massimo,r); |
---|
1374 | list W=FinalVm(V,P,K); |
---|
1375 | //print("I V ridotti in ordine sono"); |
---|
1376 | //print(W); |
---|
1377 | //list |
---|
1378 | Jms=SchemeEq(W,EK,D,P,K); |
---|
1379 | keepring K;} |
---|
1380 | } |
---|
1381 | } |
---|
1382 | else |
---|
1383 | { |
---|
1384 | print("WRONG IDEAL IN INPUT"); |
---|
1385 | print("It is NOT BOREL"); |
---|
1386 | } |
---|
1387 | return(Jms); |
---|
1388 | } |
---|
1389 | example |
---|
1390 | { "EXAMPLE:"; echo = 2; |
---|
1391 | ring r=0, (x,y,z),rp; |
---|
1392 | ideal Borid=y^2*z,y*z^2,z^3,y^5; |
---|
1393 | JMarkedScheme(Borid,r); |
---|
1394 | } |
---|
1395 | //////////////////////////////////////////////////////////////////// |
---|