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