Annotation of OpenXM/src/kan96xx/Doc/ecart.sm1, Revision 1.21
1.21 ! takayama 1: % $OpenXM: OpenXM/src/kan96xx/Doc/ecart.sm1,v 1.20 2004/05/04 08:03:30 takayama Exp $
1.1 takayama 2: %[(parse) (hol.sm1) pushfile] extension
3: %[(parse) (appell.sm1) pushfile] extension
4:
5: (ecart.sm1 : ecart division for D, 2003/07/25 ) message-quiet
6: /ecart.begin { beginEcart } def
7: /ecart.end { endEcart } def
8: /ecart.autoHomogenize 1 def
9: /ecart.needSyz 0 def
1.8 takayama 10: /ecartd.begin {
11: ecart.begin
12: [(EcartAutomaticHomogenization) 1] system_variable
13: } def
14: /ecartd.end {
15: ecart.end
16: [(EcartAutomaticHomogenization) 0] system_variable
17: } def
1.1 takayama 18:
1.15 takayama 19: /ecart.setOpt {
20: /arg1 set
21: [/in-ecart.setOpt /opt /i /n /ans] pushVariables
22: [
23: /opt arg1 def
24: /ans [ ] def
25: /n opt length def
26: 0 2 n 1 sub {
27: /i set
28: opt i get tag StringP eq not {
29: (ecart.setOpt : [keyword value keyword value ....] ) error
30: } { } ifelse
31: { % start of the loop
32: % Global: degreeShift
33: opt i get (degreeShift) eq {
34: /degreeShift opt i 1 add get def
35: exit
36: } { } ifelse
37: % Global: hdShift
38: opt i get (startingShift) eq {
39: /hdShift opt i 1 add get def
40: exit
41: } { } ifelse
42: % Global: hdShift
43: opt i get (noAutoHomogenize) eq {
44: /hdShift -1 def
45: exit
46: } { } ifelse
1.16 takayama 47: % Global: ecart.useSugar
48: opt i get (sugar) eq {
49: /ecart.useSugar opt i 1 add get def
50: exit
51: } { } ifelse
52:
1.15 takayama 53: ans [opt i get opt i 1 add get ] append /ans set
54: exit
55: } loop
56: } for
57:
58: ecart.gb.verbose {
59: (ecart.setOpt:) message
60: (degreeShift=) messagen degreeShift message
61: $hdShift(startingShift)=$ messagen hdShift message
1.16 takayama 62: (sugar=) messagen ecart.useSugar message
1.15 takayama 63: (Other options=) messagen ans message
64: } { } ifelse
65:
66: /arg1 ans def
67: ] pop
68: popVariables
69: arg1
70: } def
71:
1.1 takayama 72: /ecart.dehomogenize {
73: /arg1 set
74: [/in.ecart.dehomogenize /ll /rr] pushVariables
75: [
76: /ll arg1 def
77: ll tag 6 eq {
78: ll { ecart.dehomogenize } map /ll set
79: } {
80: ll (0). eq {
81: } {
82: ll getRing /rr set
83: ll [ [ (H) rr ,, (1) rr ,, ]
84: [ (h) rr ,, (1) rr ,, ]] replace
85: /ll set
86: } ifelse
87: } ifelse
88: /arg1 ll def
89: ] pop
90: popVariables
91: arg1
92: } def
93: [(ecart.dehomogenize)
94: [(obj ecart.dehomogenize r)
95: (h->1, H->1)
96: ]] putUsages
97:
98: /ecart.dehomogenizeH {
99: /arg1 set
100: [/in.ecart.dehomogenize /ll /rr] pushVariables
101: [
102: /ll arg1 def
103: ll tag 6 eq {
104: ll { ecart.dehomogenize } map /ll set
105: } {
106: ll (0). eq {
107: } {
108: ll getRing /rr set
109: ll [ [ (H) rr ,, (1) rr ,, ] ] replace
110: /ll set
111: } ifelse
112: } ifelse
113: /arg1 ll def
114: ] pop
115: popVariables
116: arg1
117: } def
118: [(ecart.dehomogenizeH)
119: [(obj ecart.dehomogenizeH r)
120: (H->1, h is not changed.)
121: ]] putUsages
122:
123: /ecart.homogenize01 {
124: /arg1 set
1.11 takayama 125: [/in.ecart.homogenize01 /ll /ll0] pushVariables
1.1 takayama 126: [
127: /ll arg1 def
1.11 takayama 128: ll tag ArrayP eq {
129: ll 0 get tag ArrayP eq not {
130: [(degreeShift) [ ] ll ] homogenize /arg1 set
131: } {
132: ll { ecart.homogenize01 } map /arg1 set
133: } ifelse
134: } {
135: [(degreeShift) [ ] ll ] homogenize /arg1 set
1.12 takayama 136: } ifelse
1.1 takayama 137: ] pop
138: popVariables
139: arg1
140: } def
141: [(ecart.homogenize01)
142: [(obj ecart.homogenize01 r)
143: (Example: )
144: ( [(x1,x2) ring_of_differential_operators )
145: ( [[(H) 1 (h) 1 (x1) 1 (x2) 1] )
146: ( [(h) 1 (Dx1) 1 (Dx2) 1] )
147: ( [(Dx1) 1 (Dx2) 1] )
148: ( [(x1) -1 (x2) -1])
1.18 takayama 149: ( ] ecart.weight_vector )
1.1 takayama 150: ( 0 )
1.11 takayama 151: ( [(weightedHomogenization) 1 (degreeShift) [[0 0 0]]])
1.1 takayama 152: ( ] define_ring)
153: ( ecart.begin)
154: ( [[1 -4 -2 5]] appell4 0 get /eqs set)
155: ( eqs { . [[(x1). (x1+2).] [(x2). (x2+4).]] replace} map )
1.11 takayama 156: ( {ecart.homogenize01} map /eqs2 set)
1.1 takayama 157: ( [eqs2] groebner )
158: ]] putUsages
159:
160: /ecart.homogenize01_with_shiftVector {
161: /arg2.set
162: /arg1 set
1.11 takayama 163: [/in.ecart.homogenize01 /ll /sv /ll0] pushVariables
1.1 takayama 164: [
165: /sv arg2 def
166: /ll arg1 def
1.11 takayama 167: ll tag ArrayP eq {
168: ll 0 get tag ArrayP eq not {
169: [(degreeShift) sv ll ] homogenize /arg1 set
170: } {
171: ll { ecart.homogenize01_with_shiftVector } map /arg1 set
172: } ifelse
173: } {
174: [(degreeShift) sv ll ] homogenize /arg1 set
1.12 takayama 175: } ifelse
1.1 takayama 176: ] pop
177: popVariables
178: arg1
179: } def
180: [(ecart.dehomogenize01_with_degreeShift)
181: [(obj shift-vector ecart.dehomogenize01_with_degreeShift r)
1.11 takayama 182: (cf. homogenize)
1.1 takayama 183: ]] putUsages
184:
185: %% Aux functions to return the default weight vectors.
186: /ecart.wv1 {
187: /arg1 set
188: [/in.ecart.wv1 /v] pushVariables
189: [
190: /v arg1 def
191: [(H) (h) v to_records pop] /v set
192: v { 1 } map /v set
193: /arg1 v def
194: ] pop
195: popVariables
196: arg1
197: } def
198: /ecart.wv2 {
199: /arg1 set
200: [/in.ecart.wv2 /v] pushVariables
201: [
202: /v arg1 def
203: [v to_records pop] /v set
204: v { [ @@@.Dsymbol 3 -1 roll ] cat 1 } map /v set
205: [(h) 1 ] v join /v set
206: /arg1 v def
207: ] pop
208: popVariables
209: arg1
210: } def
211:
1.7 takayama 212: /ecart.gb {ecartd.gb} def
213:
214: [(ecart.gb)
215: [(a ecart.gb b)
216: (array a; array b;)
217: $b : [g ii]; array g; array in; g is a standard (Grobner) basis of f$
218: ( in the ring of differential operators.)
219: (The computation is done by using Ecart division algorithm and )
220: (the double homogenization.)
221: (cf. M.Granger and T.Oaku: Minimal filtered free resolutions ... 2003)
222: $ ii is the initial ideal in case of w is given or <<a>> belongs$
223: $ to a ring. In the other cases, it returns the initial monominal.$
224: (a : [f ]; array f; f is a set of generators of an ideal in a ring.)
225: (a : [f v]; array f; string v; v is the variables. )
226: (a : [f v w]; array f; string v; array of array w; w is the weight matirx.)
1.15 takayama 227: $a : [f v w [(degreeShift) ds]]; array f; string v; array of array w; w is the weight matirx.$
1.11 takayama 228: ( array ds; ds is the degree shift for the ring. )
1.15 takayama 229: $a : [f v w [(degreeShift) ds (startingShift) hdShift]]; array f; string v; array of array w; w is the weight matirx.$
1.11 takayama 230: ( array ds; ds is the degree shift for the ring. )
231: ( array hsShift is the degree shift for the homogenization. cf.homogenize )
1.15 takayama 232: $a : [f v w [(degreeShift) ds (noAutoHomogenize) 1]]; array f; string v; array of array w; w is the weight matirx.$
1.11 takayama 233: ( No automatic homogenization.)
1.16 takayama 234: $ [(degreeShift) ds (noAutoHomogenize) 1 (sugar) 1] -->use the sugar strate $
1.7 takayama 235: ( )
1.19 takayama 236: $cf. ecarth.gb (homogenized), ecartd.gb (dehomogenize), ecartd.reduction $
1.7 takayama 237: ( )
238: $Example 1: [ [( (x Dx)^2 + (y Dy)^2 -1) ( x y Dx Dy -1)] (x,y) $
239: $ [ [ (Dx) 1 ] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]] ] ecart.gb pmat ; $
240: (Example 2: )
241: $ [ [(2 x Dx + 3 y Dy+6) (2 y Dx + 3 x^2 Dy)] (x,y) $
1.9 takayama 242: $ [[(x) -1 (Dx) 1 (y) -1 (Dy) 1]]] ecart.gb /ff set ff pmat ;$
243: (To set the current ring to the ring in which ff belongs )
244: ( ff getRing ring_def )
1.7 takayama 245: ( )
246: $Example 3: [ [( (x Dx)^2 + (y Dy)^2 -1) ( x y Dx Dy -1)] (x,y) $
247: $ [ [ (Dx) 1 (Dy) 1] ] ] ecart.gb pmat ; $
1.10 takayama 248: ( This example will cause an error on order.)
1.7 takayama 249: ( )
250: $Example 4: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $
251: $ [ [ (x) -1 (y) -1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]] ] ecart.gb pmat ; $
1.10 takayama 252: ( This example will cause an error on order.)
1.7 takayama 253: ( )
254: $Example 5: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $
1.15 takayama 255: $ [ [(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1] ] $
256: $ [(degreeShift) [[0 1] [-3 1]]] ] ecart.gb pmat ; $
1.7 takayama 257: ( )
258: (cf. gb, groebner, ecarth.gb, ecartd.gb, ecart.syz, ecart.begin, ecart.end, ecart.homogenize01, )
259: ( ecart.dehomogenize, ecart.dehomogenizeH)
260: ( [(weightedHomogenization) 1 (degreeShift) [[1 2 1]]] : options for )
261: ( define_ring )
262: (/ecart.autoHomogenize 0 def )
263: ( not to dehomogenize and homogenize)
264: ]] putUsages
265:
1.1 takayama 266: /ecart.gb.verbose 1 def
1.12 takayama 267: %ecarth.gb s(H)-homogenized outputs. GG's original version of ecart gb.
1.7 takayama 268: /ecarth.gb {
1.1 takayama 269: /arg1 set
1.7 takayama 270: [/in-ecarth.gb /aa /typev /setarg /f /v
1.1 takayama 271: /gg /wv /vec /ans /rr /mm
272: /degreeShift /env2 /opt /ans.gb
1.12 takayama 273: /hdShift
1.17 takayama 274: /ecart.useSugar
1.1 takayama 275: ] pushVariables
276: [(CurrentRingp) (KanGBmessage)] pushEnv
277: [
278: /aa arg1 def
1.13 takayama 279: aa isArray { } { ( << array >> ecarth.gb) error } ifelse
1.1 takayama 280: /setarg 0 def
281: /wv 0 def
282: /degreeShift 0 def
1.12 takayama 283: /hdShift 0 def
1.1 takayama 284: /opt [(weightedHomogenization) 1] def
1.17 takayama 285: /ecart.useSugar 0 def
1.1 takayama 286: aa { tag } map /typev set
287: typev [ ArrayP ] eq
288: { /f aa 0 get def
289: /v gb.v def
290: /setarg 1 def
291: } { } ifelse
292: typev [ArrayP StringP] eq
293: { /f aa 0 get def
294: /v aa 1 get def
295: /setarg 1 def
296: } { } ifelse
297: typev [ArrayP RingP] eq
298: { /f aa 0 get def
299: /v aa 1 get def
300: /setarg 1 def
301: } { } ifelse
302: typev [ArrayP ArrayP] eq
303: { /f aa 0 get def
304: /v aa 1 get from_records def
305: /setarg 1 def
306: } { } ifelse
307: typev [ArrayP StringP ArrayP] eq
308: { /f aa 0 get def
309: /v aa 1 get def
310: /wv aa 2 get def
311: /setarg 1 def
312: } { } ifelse
313: typev [ArrayP ArrayP ArrayP] eq
314: { /f aa 0 get def
315: /v aa 1 get from_records def
316: /wv aa 2 get def
317: /setarg 1 def
318: } { } ifelse
1.15 takayama 319:
1.1 takayama 320: typev [ArrayP StringP ArrayP ArrayP] eq
321: { /f aa 0 get def
322: /v aa 1 get def
323: /wv aa 2 get def
1.15 takayama 324: opt aa 3 get ecart.setOpt join /opt set
1.12 takayama 325: /setarg 1 def
326: } { } ifelse
1.1 takayama 327: typev [ArrayP ArrayP ArrayP ArrayP] eq
328: { /f aa 0 get def
329: /v aa 1 get from_records def
330: /wv aa 2 get def
1.15 takayama 331: opt aa 3 get ecart.setOpt join /opt set
1.13 takayama 332: /setarg 1 def
333: } { } ifelse
1.1 takayama 334:
335: /env1 getOptions def
336:
1.12 takayama 337: ecart.gb.verbose { $ecarth.gb computes std basis with h-s(H)-homogenized buchberger algorithm.$ message } { } ifelse
338: setarg { } { (ecarth.gb : Argument mismatch) error } ifelse
1.1 takayama 339:
340: [(KanGBmessage) ecart.gb.verbose ] system_variable
341:
342: %%% Start of the preprocess
343: v tag RingP eq {
344: /rr v def
345: }{
346: f getRing /rr set
347: } ifelse
348: %% To the normal form : matrix expression.
349: f gb.toMatrixOfString /f set
350: /mm gb.itWasMatrix def
351:
352: rr tag 0 eq {
353: %% Define our own ring
354: v isInteger {
355: (Error in gb: Specify variables) error
356: } { } ifelse
357: wv isInteger {
358: [v ring_of_differential_operators
1.18 takayama 359: % [ v ecart.wv1 v ecart.wv2 ] ecart.weight_vector
1.3 takayama 360: gb.characteristic
1.1 takayama 361: opt
362: ] define_ring
363: }{
364: degreeShift isInteger {
365: [v ring_of_differential_operators
1.18 takayama 366: % [v ecart.wv1 v ecart.wv2] wv join ecart.weight_vector
367: wv ecart.weight_vector
1.3 takayama 368: gb.characteristic
1.1 takayama 369: opt
370: ] define_ring
371:
372: }{
373: [v ring_of_differential_operators
1.18 takayama 374: % [v ecart.wv1 v ecart.wv2] wv join ecart.weight_vector
375: wv ecart.weight_vector
1.3 takayama 376: gb.characteristic
1.1 takayama 377: [(degreeShift) degreeShift] opt join
378: ] define_ring
379:
380: } ifelse
381: } ifelse
382: } {
383: %% Use the ring structre given by the input.
384: v isInteger not {
385: gb.warning {
386: (Warning : the given ring definition is not used.) message
387: } { } ifelse
388: } { } ifelse
389: rr ring_def
390: /wv rr gb.getWeight def
391:
392: } ifelse
393: %%% Enf of the preprocess
394:
395: ecart.gb.verbose {
1.6 takayama 396: (The first and the second weight vectors for automatic homogenization: )
1.1 takayama 397: message
398: v ecart.wv1 message
399: v ecart.wv2 message
400: degreeShift isInteger { }
401: {
402: (The degree shift is ) messagen
403: degreeShift message
404: } ifelse
405: } { } ifelse
406:
1.5 takayama 407: %%BUG: case of v is integer
408: v ecart.checkOrder
409:
1.1 takayama 410: ecart.begin
411:
412: ecart.gb.verbose { (gb.options = ) messagen gb.options message } { } ifelse
1.13 takayama 413:
1.12 takayama 414:
415: hdShift tag 1 eq {
416: ecart.autoHomogenize not hdShift -1 eq or {
417: % No automatic h-s-homogenization.
418: f { {. } map} map /f set
419: } {
420: % Automatic h-s-homogenization without degreeShift
1.13 takayama 421: (ecarth.gb: Input polynomial or vectors are automatically h-H-homogenized without degree shift.)
422: message
1.12 takayama 423: f { {. ecart.dehomogenize} map} map /f set
424: f ecart.homogenize01 /f set
425: } ifelse
426: } {
427: % Automatic h-s-homogenization with degreeShift
1.13 takayama 428: (ecarth.gb: Input polynomial or vectors are automatically h-H-homogenized with degree shift.)
429: message
1.12 takayama 430: f { {. ecart.dehomogenize} map} map /f set
431: f {/fi set [(degreeShift) hdShift fi] homogenize} map /f set
432: }ifelse
433:
1.17 takayama 434: ecart.useSugar {
435: ecart.needSyz {
436: [f [(needSyz)] gb.options join ] groebner_sugar /gg set
437: } {
438: [f gb.options] groebner_sugar 0 get /gg set
439: } ifelse
440: } {
441: ecart.needSyz {
442: [f [(needSyz)] gb.options join ] groebner /gg set
443: } {
444: [f gb.options] groebner 0 get /gg set
445: } ifelse
1.1 takayama 446: } ifelse
447:
448: ecart.needSyz {
449: mm {
450: gg 0 get { /tmp set [mm tmp] toVectors } map /ans.gb set
1.11 takayama 451: } { /ans.gb gg 0 get def } ifelse
452: /ans [gg 2 get , ans.gb , gg 1 get , f ] def
453: % ans pmat ;
1.1 takayama 454: } {
455: wv isInteger {
456: /ans [gg gg {init} map] def
457: }{
1.10 takayama 458: degreeShift isInteger {
459: /ans [gg gg {wv 0 get weightv init} map] def
460: } {
461: /ans [gg gg {[wv 0 get weightv degreeShift 0 get ] init} map] def
462: } ifelse
1.1 takayama 463: }ifelse
464:
465: %% Postprocess : recover the matrix expression.
466: mm {
467: ans { /tmp set [mm tmp] toVectors } map
468: /ans set
469: }{ }
470: ifelse
471: } ifelse
472:
473: ecart.end
474:
475: %%
476: env1 restoreOptions %% degreeShift changes "grade"
477:
478: /arg1 ans def
479: ] pop
480: popEnv
481: popVariables
482: arg1
483: } def
1.7 takayama 484: (ecarth.gb ) messagen-quiet
1.1 takayama 485:
1.7 takayama 486: [(ecarth.gb)
487: [(a ecarth.gb b)
1.1 takayama 488: (array a; array b;)
489: $b : [g ii]; array g; array in; g is a standard (Grobner) basis of f$
490: ( in the ring of differential operators.)
1.12 takayama 491: (The computation is done by using Ecart division algorithm.)
492: $Buchberger algorithm is applied for double h-H(s)-homogenized elements and$
493: (they are not dehomogenized.)
1.1 takayama 494: (cf. M.Granger and T.Oaku: Minimal filtered free resolutions ... 2003)
495: $ ii is the initial ideal in case of w is given or <<a>> belongs$
496: $ to a ring. In the other cases, it returns the initial monominal.$
497: (a : [f ]; array f; f is a set of generators of an ideal in a ring.)
498: (a : [f v]; array f; string v; v is the variables. )
499: (a : [f v w]; array f; string v; array of array w; w is the weight matirx.)
1.15 takayama 500: $a : [f v w [(degreeShift) ds]]; array f; string v; array of array w; w is the weight matirx.$
1.1 takayama 501: ( array ds; ds is the degree shift )
502: ( )
503: (/ecart.autoHomogenize 0 def )
504: ( not to dehomogenize and homogenize)
505: ( )
506: $Example 1: [ [( (x Dx)^2 + (y Dy)^2 -1) ( x y Dx Dy -1)] (x,y) $
1.7 takayama 507: $ [ [ (Dx) 1 ] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]] ] ecarth.gb pmat ; $
1.1 takayama 508: (Example 2: )
509: (To put H and h=1, type in, e.g., )
510: $ [ [(2 x Dx + 3 y Dy+6) (2 y Dx + 3 x^2 Dy)] (x,y) $
1.7 takayama 511: $ [[(x) -1 (Dx) 1 (y) -1 (Dy) 1]]] ecarth.gb /gg set gg ecart.dehomogenize pmat ;$
1.1 takayama 512: ( )
513: $Example 3: [ [( (x Dx)^2 + (y Dy)^2 -1) ( x y Dx Dy -1)] (x,y) $
1.7 takayama 514: $ [ [ (Dx) 1 (Dy) 1] ] ] ecarth.gb pmat ; $
1.1 takayama 515: ( )
516: $Example 4: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $
1.7 takayama 517: $ [ [ (x) -1 (y) -1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]] ] ecarth.gb pmat ; $
1.1 takayama 518: ( )
519: $Example 5: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $
1.15 takayama 520: $ [ [(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1] ] $
521: $ [(degreeShift) [[0 1] [-3 1] ]] ] ecarth.gb pmat ; $
1.1 takayama 522: ( )
1.7 takayama 523: (cf. gb, groebner, ecart.gb, ecartd.gb, ecart.syz, ecart.begin, ecart.end, ecart.homogenize01, )
1.1 takayama 524: ( ecart.dehomogenize, ecart.dehomogenizeH)
525: ( [(weightedHomogenization) 1 (degreeShift) [[1 2 1]]] : options for )
526: ( define_ring )
527: ]] putUsages
528:
529:
530: /ecart.syz {
531: /arg1 set
532: [/in-ecart.syz /ecart.save.needSyz /ff /ff.ans] pushVariables
533: [
534: /ff arg1 def
535: /ecart.save.needSyz ecart.needSyz def
536: /ecart.needSyz 1 def
537: ff ecart.gb /ff.ans set
538: /ecart.needSyz ecart.save.needSyz def
539: /arg1 ff.ans def
540: ] pop
541: popVariables
542: arg1
543: } def
544: (ecart.syz ) messagen-quiet
545:
546: [(ecart.syz)
547: [(a ecart.syz b)
548: (array a; array b;)
549: $b : [syzygy gb tmat input]; gb = tmat * input $
550: $Example 1: [ [( (x Dx)^2 + (y Dy)^2 -1) ( x y Dx Dy -1)] (x,y) $
1.8 takayama 551: $ [ [ (Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]] ] ecart.syz /ff set $
1.1 takayama 552: $ ff 0 get ff 3 get mul pmat $
553: $ ff 2 get ff 3 get mul [ff 1 get ] transpose sub pmat ; $
554: ( )
1.9 takayama 555: (To set the current ring to the ring in which ff belongs )
556: ( ff getRing ring_def )
1.1 takayama 557: $Example 2: [[ [(x^2) (y+x)] [(x+y) (y^3)] [(2 x^2+x y) (y+x+x y^3)]] (x,y) $
1.8 takayama 558: $ [ [(Dx) 1 (Dy) 1] [ (x) -1 (y) -1] ] [[0 1] [-3 1] ] ] ecart.syz pmat ; $
1.1 takayama 559: ( )
560: (cf. ecart.gb)
561: ( /ecart.autoHomogenize 0 def )
562: ]] putUsages
1.2 takayama 563:
1.3 takayama 564:
565: /ecartn.begin {
566: (red@) (standard) switch_function
567: %% (red@) (ecart) switch_function
568: [(Ecart) 1] system_variable
569: [(CheckHomogenization) 0] system_variable
570: [(ReduceLowerTerms) 0] system_variable
571: [(AutoReduce) 0] system_variable
572: [(EcartAutomaticHomogenization) 0] system_variable
573: } def
574: /ecartn.gb {
575: /arg1 set
576: [/in-ecartn.gb /aa /typev /setarg /f /v
577: /gg /wv /vec /ans /rr /mm
578: /degreeShift /env2 /opt /ans.gb
579: ] pushVariables
580: [(CurrentRingp) (KanGBmessage)] pushEnv
581: [
582: /aa arg1 def
1.13 takayama 583: aa isArray { } { ( << array >> ecartn.gb) error } ifelse
1.3 takayama 584: /setarg 0 def
585: /wv 0 def
586: /degreeShift 0 def
587: /opt [(weightedHomogenization) 1] def
588: aa { tag } map /typev set
589: typev [ ArrayP ] eq
590: { /f aa 0 get def
591: /v gb.v def
592: /setarg 1 def
593: } { } ifelse
594: typev [ArrayP StringP] eq
595: { /f aa 0 get def
596: /v aa 1 get def
597: /setarg 1 def
598: } { } ifelse
599: typev [ArrayP RingP] eq
600: { /f aa 0 get def
601: /v aa 1 get def
602: /setarg 1 def
603: } { } ifelse
604: typev [ArrayP ArrayP] eq
605: { /f aa 0 get def
606: /v aa 1 get from_records def
607: /setarg 1 def
608: } { } ifelse
609: typev [ArrayP StringP ArrayP] eq
610: { /f aa 0 get def
611: /v aa 1 get def
612: /wv aa 2 get def
613: /setarg 1 def
614: } { } ifelse
615: typev [ArrayP ArrayP ArrayP] eq
616: { /f aa 0 get def
617: /v aa 1 get from_records def
618: /wv aa 2 get def
619: /setarg 1 def
620: } { } ifelse
1.15 takayama 621:
1.3 takayama 622: typev [ArrayP StringP ArrayP ArrayP] eq
623: { /f aa 0 get def
624: /v aa 1 get def
625: /wv aa 2 get def
1.15 takayama 626: opt aa 3 get ecart.setOpt join /opt set
1.3 takayama 627: /setarg 1 def
628: } { } ifelse
629: typev [ArrayP ArrayP ArrayP ArrayP] eq
630: { /f aa 0 get def
631: /v aa 1 get from_records def
632: /wv aa 2 get def
1.15 takayama 633: opt aa 3 get ecart.setOpt join /opt set
1.3 takayama 634: /setarg 1 def
635: } { } ifelse
636:
637: /env1 getOptions def
638:
639: setarg { } { (ecart.gb : Argument mismatch) error } ifelse
640:
641: [(KanGBmessage) ecart.gb.verbose ] system_variable
642:
643: %%% Start of the preprocess
644: v tag RingP eq {
645: /rr v def
646: }{
647: f getRing /rr set
648: } ifelse
649: %% To the normal form : matrix expression.
650: f gb.toMatrixOfString /f set
651: /mm gb.itWasMatrix def
652:
653: rr tag 0 eq {
654: %% Define our own ring
655: v isInteger {
656: (Error in gb: Specify variables) error
657: } { } ifelse
658: wv isInteger {
659: [v ring_of_differential_operators
1.18 takayama 660: [ v ecart.wv1 v ecart.wv2 ] ecart.weight_vector
1.3 takayama 661: gb.characteristic
662: opt
663: ] define_ring
664: }{
665: degreeShift isInteger {
666: [v ring_of_differential_operators
1.18 takayama 667: [v ecart.wv1 v ecart.wv2] wv join ecart.weight_vector
1.3 takayama 668: gb.characteristic
669: opt
670: ] define_ring
671:
672: }{
673: [v ring_of_differential_operators
1.18 takayama 674: [v ecart.wv1 v ecart.wv2] wv join ecart.weight_vector
1.3 takayama 675: gb.characteristic
676: [(degreeShift) degreeShift] opt join
677: ] define_ring
678:
679: } ifelse
680: } ifelse
681: } {
682: %% Use the ring structre given by the input.
683: v isInteger not {
684: gb.warning {
685: (Warning : the given ring definition is not used.) message
686: } { } ifelse
687: } { } ifelse
688: rr ring_def
689: /wv rr gb.getWeight def
690:
691: } ifelse
692: %%% Enf of the preprocess
693:
694: ecart.gb.verbose {
695: (The first and the second weight vectors are automatically set as follows)
696: message
697: v ecart.wv1 message
698: v ecart.wv2 message
699: degreeShift isInteger { }
700: {
701: (The degree shift is ) messagen
702: degreeShift message
703: } ifelse
704: } { } ifelse
705:
1.5 takayama 706: %%BUG: case of v is integer
707: v ecart.checkOrder
708:
1.3 takayama 709: ecartn.begin
710:
711: ecart.gb.verbose { (ecartn.gb : ecart.gb without ecart division.) message } { } ifelse
712: ecart.gb.verbose { (gb.options = ) messagen gb.options message } { } ifelse
713: ecart.autoHomogenize {
714: (ecart.gb: Input polynomial or vectors are automatically h-H-homogenized.)
715: message
716: } { } ifelse
717: ecart.autoHomogenize {
718: f { {. ecart.dehomogenize} map} map /f set
719: f ecart.homogenize01 /f set
720: }{
721: f { {. } map } map /f set
722: } ifelse
723: ecart.needSyz {
724: [f [(needSyz)] gb.options join ] groebner /gg set
725: } {
726: [f gb.options] groebner 0 get /gg set
727: } ifelse
728:
729: ecart.needSyz {
730: mm {
731: gg 0 get { /tmp set [mm tmp] toVectors } map /ans.gb set
732: } { /ans.gb gg 0 get def } ifelse
733: /ans [gg 2 get , ans.gb , gg 1 get , f ] def
1.11 takayama 734: % ans pmat ;
1.3 takayama 735: } {
736: wv isInteger {
737: /ans [gg gg {init} map] def
738: }{
1.10 takayama 739: degreeShift isInteger {
740: /ans [gg gg {wv 0 get weightv init} map] def
741: } {
742: /ans [gg gg {[wv 0 get weightv degreeShift 0 get ] init} map] def
743: } ifelse
1.3 takayama 744: }ifelse
745:
746: %% Postprocess : recover the matrix expression.
747: mm {
748: ans { /tmp set [mm tmp] toVectors } map
749: /ans set
750: }{ }
751: ifelse
752: } ifelse
753:
754: ecart.end
755:
756: %%
757: env1 restoreOptions %% degreeShift changes "grade"
758:
759: /arg1 ans def
760: ] pop
761: popEnv
762: popVariables
763: arg1
764: } def
765: (ecartn.gb[gb by non-ecart division] ) messagen-quiet
1.4 takayama 766:
767: /ecartd.gb {
768: /arg1 set
769: [/in-ecart.gb /aa /typev /setarg /f /v
770: /gg /wv /vec /ans /rr /mm
771: /degreeShift /env2 /opt /ans.gb
1.11 takayama 772: /hdShift
1.16 takayama 773: /ecart.useSugar
1.4 takayama 774: ] pushVariables
775: [(CurrentRingp) (KanGBmessage)] pushEnv
776: [
777: /aa arg1 def
1.13 takayama 778: aa isArray { } { ( << array >> ecartd.gb) error } ifelse
1.4 takayama 779: /setarg 0 def
780: /wv 0 def
781: /degreeShift 0 def
1.11 takayama 782: /hdShift 0 def
1.16 takayama 783: /ecart.useSugar 0 def
1.4 takayama 784: /opt [(weightedHomogenization) 1] def
785: aa { tag } map /typev set
786: typev [ ArrayP ] eq
787: { /f aa 0 get def
788: /v gb.v def
789: /setarg 1 def
790: } { } ifelse
791: typev [ArrayP StringP] eq
792: { /f aa 0 get def
793: /v aa 1 get def
794: /setarg 1 def
795: } { } ifelse
796: typev [ArrayP RingP] eq
797: { /f aa 0 get def
798: /v aa 1 get def
799: /setarg 1 def
800: } { } ifelse
801: typev [ArrayP ArrayP] eq
802: { /f aa 0 get def
803: /v aa 1 get from_records def
804: /setarg 1 def
805: } { } ifelse
806: typev [ArrayP StringP ArrayP] eq
807: { /f aa 0 get def
808: /v aa 1 get def
809: /wv aa 2 get def
810: /setarg 1 def
811: } { } ifelse
812: typev [ArrayP ArrayP ArrayP] eq
813: { /f aa 0 get def
814: /v aa 1 get from_records def
815: /wv aa 2 get def
816: /setarg 1 def
817: } { } ifelse
1.15 takayama 818:
1.4 takayama 819: typev [ArrayP StringP ArrayP ArrayP] eq
820: { /f aa 0 get def
821: /v aa 1 get def
822: /wv aa 2 get def
1.15 takayama 823: opt aa 3 get ecart.setOpt join /opt set
1.4 takayama 824: /setarg 1 def
825: } { } ifelse
826: typev [ArrayP ArrayP ArrayP ArrayP] eq
827: { /f aa 0 get def
828: /v aa 1 get from_records def
829: /wv aa 2 get def
1.15 takayama 830: opt aa 3 get ecart.setOpt join /opt set
1.13 takayama 831: /setarg 1 def
832: } { } ifelse
1.4 takayama 833:
834: /env1 getOptions def
835:
836: setarg { } { (ecart.gb : Argument mismatch) error } ifelse
837:
838: [(KanGBmessage) ecart.gb.verbose ] system_variable
839: $ecartd.gb dehomogenizes at each reduction step w.r.t. s (H).$ message
840:
841: %%% Start of the preprocess
842: v tag RingP eq {
843: /rr v def
844: }{
845: f getRing /rr set
846: } ifelse
847: %% To the normal form : matrix expression.
848: f gb.toMatrixOfString /f set
849: /mm gb.itWasMatrix def
850:
851: rr tag 0 eq {
852: %% Define our own ring
853: v isInteger {
854: (Error in gb: Specify variables) error
855: } { } ifelse
856: wv isInteger {
857: (Give an weight vector such that x < 1) error
858: }{
859: degreeShift isInteger {
860: [v ring_of_differential_operators
1.18 takayama 861: wv ecart.weight_vector
1.4 takayama 862: gb.characteristic
863: opt
864: ] define_ring
865:
866: }{
867: [v ring_of_differential_operators
1.18 takayama 868: wv ecart.weight_vector
1.4 takayama 869: gb.characteristic
870: [(degreeShift) degreeShift] opt join
871: ] define_ring
872:
873: } ifelse
874: } ifelse
875: } {
876: %% Use the ring structre given by the input.
877: v isInteger not {
878: gb.warning {
879: (Warning : the given ring definition is not used.) message
880: } { } ifelse
881: } { } ifelse
882: rr ring_def
883: /wv rr gb.getWeight def
884:
885: } ifelse
886: %%% Enf of the preprocess
887:
888: ecart.gb.verbose {
889: degreeShift isInteger { }
890: {
891: (The degree shift is ) messagen
892: degreeShift message
893: } ifelse
894: } { } ifelse
895:
1.5 takayama 896: %%BUG: case of v is integer
897: v ecart.checkOrder
898:
1.8 takayama 899: ecartd.begin
1.4 takayama 900:
901: ecart.gb.verbose { (gb.options = ) messagen gb.options message } { } ifelse
902:
1.11 takayama 903: hdShift tag 1 eq {
1.12 takayama 904: ecart.autoHomogenize not hdShift -1 eq or {
1.11 takayama 905: % No automatic h-homogenization.
906: f { {. } map} map /f set
907: } {
908: % Automatic h-homogenization without degreeShift
1.13 takayama 909: (ecartd.gb : Input polynomial or vectors are automatically homogenized without degreeShift) message
1.11 takayama 910: f { {. ecart.dehomogenize} map} map /f set
911: f ecart.homogenize01 /f set
912: f { { [[(H). (1).]] replace } map } map /f set
913: } ifelse
914: } {
915: % Automatic h-homogenization with degreeShift
1.13 takayama 916: (ecartd.gb : Input polynomial or vectors are automatically homogenized with degreeShift) message
1.11 takayama 917: f { {. ecart.dehomogenize} map} map /f set
918: f {/fi set [(degreeShift) hdShift fi] homogenize} map /f set
919: f { { [[(H). (1).]] replace } map } map /f set
920: }ifelse
1.4 takayama 921:
1.16 takayama 922: ecart.useSugar {
923: ecart.needSyz {
924: [f [(needSyz)] gb.options join ] groebner_sugar /gg set
925: } {
926: [f gb.options] groebner_sugar 0 get /gg set
927: } ifelse
928: } {
929: ecart.needSyz {
930: [f [(needSyz)] gb.options join ] groebner /gg set
931: } {
932: [f gb.options] groebner 0 get /gg set
933: } ifelse
1.4 takayama 934: } ifelse
935:
936: ecart.needSyz {
937: mm {
938: gg 0 get { /tmp set [mm tmp] toVectors } map /ans.gb set
939: } { /ans.gb gg 0 get def } ifelse
940: /ans [gg 2 get , ans.gb , gg 1 get , f ] def
1.11 takayama 941: % ans pmat ;
1.4 takayama 942: } {
943: wv isInteger {
944: /ans [gg gg {init} map] def
945: }{
1.11 takayama 946: %% Get the initial ideal
1.10 takayama 947: degreeShift isInteger {
948: /ans [gg gg {wv 0 get weightv init} map] def
949: } {
950: /ans [gg gg {[wv 0 get weightv degreeShift 0 get ] init} map] def
951: } ifelse
1.4 takayama 952: }ifelse
953:
954: %% Postprocess : recover the matrix expression.
955: mm {
956: ans { /tmp set [mm tmp] toVectors } map
957: /ans set
958: }{ }
959: ifelse
960: } ifelse
961:
1.8 takayama 962: ecartd.end
1.4 takayama 963:
964: %%
965: env1 restoreOptions %% degreeShift changes "grade"
966:
967: /arg1 ans def
968: ] pop
969: popEnv
970: popVariables
971: arg1
972: } def
973: (ecartd.gb[results are dehomogenized at each reduction step] ) messagen-quiet
1.2 takayama 974:
1.5 takayama 975: /ecart.checkOrder {
976: /arg1 set
977: [/in-ecart.checkOrder /vv /tt /dd /n /i] pushVariables
978: [
979: /vv arg1 def
980: vv isArray
981: { } { [vv to_records pop] /vv set } ifelse
982: vv {toString} map /vv set
983: vv { /tt set [@@@.Dsymbol tt] cat } map /dd set
984: % Starting the checks.
985: 0 1 vv length 1 sub {
986: /i set
987: vv i get . dd i get . mul /tt set
988: tt @@@.hsymbol . add init tt eq { }
989: { [@@@.hsymbol ( is larger than ) vv i get ( ) dd i get] cat error} ifelse
990: } for
991:
992: 0 1 vv length 1 sub {
993: /i set
994: vv i get . /tt set
995: tt (1). add init (1). eq { }
1.6 takayama 996: { [vv i get ( is larger than 1 ) ] cat error} ifelse
1.5 takayama 997: } for
998: /arg1 1 def
999: ] pop
1000: popVariables
1001: arg1
1002: } def
1003: [(ecart.checkOrder)
1004: [(v ecart.checkOrder bool checks if the given order is relevant)
1005: (for the ecart division.)
1006: (cf. ecartd.gb, ecart.gb, ecartn.gb)
1007: ]
1008: ] putUsages
1009:
1010: /ecart.wv_last {
1011: /arg1 set
1012: [/in-ecart.wv_last /vv /tt /dd /n /i] pushVariables
1013: [
1014: /vv arg1 def
1015: vv isArray
1016: { } { [vv to_records pop] /vv set } ifelse
1017: vv {toString} map /vv set
1018: vv { /tt set [@@@.Dsymbol tt] cat } map /dd set
1019: vv { -1 } map
1020: dd { 1 } map join /arg1 set
1021: ] pop
1022: popVariables
1023: arg1
1024: } def
1025: [(ecart.wv_last)
1026: [(v ecart.wv_last wt )
1027: (It returns the weight vector -1,-1,...-1; 1,1, ..., 1)
1028: (Use this weight vector as the last weight vector for ecart division)
1029: (if ecart.checkOrder complains about the order given.)
1030: ]
1031: ] putUsages
1.13 takayama 1032:
1033: /ecart.mimimalBase.test {
1034: [
1035: [ (0) , (-2*Dx) , (2*t) , (y) , (x^2) ]
1036: [ (3*t ) , ( -3*Dy ) , ( 0 ) , ( -x ) , ( -y) ]
1037: [ (3*y ) , ( 6*Dt ) , ( 2*x ) , ( 0 ) , ( 1) ]
1038: [ (-3*x^2 ) , ( 0 ) , ( -2*y ) , ( 1 ) , ( 0 )]
1039: [ (Dx ) , ( 0 ) , ( -Dy ) , ( Dt ) , ( 0) ]
1040: [ (0 ) , ( 0 ) , ( 6*t*Dt+2*x*Dx+3*y*Dy+8*h ) , ( 0 ) , ( 3*x^2*Dt+Dx) ]
1041: [ (6*t*Dx ) , ( 0 ) , ( -6*t*Dy ) , ( -2*x*Dx-3*y*Dy-5*h ) , ( -2*y*Dx-3*x^2*Dy) ]
1042: [ (6*t*Dt+3*y*Dy+9*h ) , ( 0 ) , ( 2*x*Dy ) , ( -2*x*Dt ) , ( -2*y*Dt+Dy) ]
1043: ]
1044: /ff set
1045:
1046: /nmshift [ [1 0 1 1 1] [1 0 1 0 0] ] def
1047: /shift [ [1 0 1 0 0] ] def
1048: /weight [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] def
1049:
1.15 takayama 1050: [ff (t,x,y) weight [(degreeShift) shift (startingShift) nmshift]] ecart.minimalBase
1.13 takayama 1051:
1052:
1053: } def
1054: /test {ecart.mimimalBase.test} def
1055:
1056: %(x,y) ==> [(Dx) 1 (Dy) 1 (h) 1]
1057: /ecart.minimalBase.D1 {
1058: /arg1 set
1059: [/in-ecart.minimalBase.D1 /tt /v] pushVariables
1060: [
1061: /v arg1 def
1062: [ v to_records pop] /v set
1063: v { /tt set [@@@.Dsymbol tt] cat 1 } map /v set
1064: v [(h) 1] join /arg1 set
1065: ] pop
1066: popVariables
1067: arg1
1068: } def
1069:
1070: % [0 1 2] 1 ecart.removeElem [0 2]
1071: /ecart.removeElem {
1072: /arg2 set
1073: /arg1 set
1074: [/in-ecart.removeElem /v /q /i /ans /j] pushVariables
1075: [
1076: /v arg1 def
1077: /q arg2 def
1078: /ans v length 1 sub newVector def
1079: /j 0 def
1080: 0 1 v length 1 sub {
1081: /i set
1082: i q eq not {
1083: ans j v i get put
1084: /j j 1 add def
1085: } { } ifelse
1086: } for
1087: ] pop
1088: popVariables
1089: arg1
1090: } def
1091:
1.14 takayama 1092: /ecart.isZeroRow {
1093: /arg1 set
1094: [/in-ecart.isZeroRow /aa /i /n /yes] pushVariables
1095: [
1096: /aa arg1 def
1097: aa length /n set
1098: /yes 1 def
1099: 0 1 n 1 sub {
1100: /i set
1101: aa i get (0). eq {
1102: } {
1103: /yes 0 def
1104: } ifelse
1105: } for
1106: /arg1 yes def
1107: ] pop
1108: popVariables
1109: arg1
1110: } def
1111:
1112: /ecart.removeZeroRow {
1113: /arg1 set
1114: [/in-ecart.removeZeroRow /aa /i /n /ans] pushVariables
1115: [
1116: /aa arg1 def
1117: aa length /n set
1118: /ans [ ] def
1119: 0 1 n 1 sub {
1120: /i set
1121: aa i get ecart.isZeroRow {
1122: } {
1123: ans aa i get append /ans set
1124: } ifelse
1125: } for
1126: /arg1 ans def
1127: ] pop
1128: popVariables
1129: arg1
1130: } def
1131:
1132: /ecart.gen_input {
1133: /arg1 set
1134: [/in-ecart.gen_input /aa /typev /setarg /f /v
1135: /gg /wv /vec /ans /rr /mm
1136: /degreeShift /env2 /opt /ss0
1137: /hdShift /ff
1138: ] pushVariables
1139: [
1140: /aa arg1 def
1141: aa isArray { } { ( << array >> ecart.gen_input) error } ifelse
1142: /setarg 0 def
1143: /wv 0 def
1144: /degreeShift 0 def
1145: /hdShift 0 def
1.15 takayama 1146: /opt [ ] def
1.14 takayama 1147: aa { tag } map /typev set
1.15 takayama 1148: typev [ArrayP StringP ArrayP ArrayP] eq
1.14 takayama 1149: { /f aa 0 get def
1150: /v aa 1 get def
1151: /wv aa 2 get def
1.15 takayama 1152: opt aa 3 get ecart.setOpt join /opt set
1.14 takayama 1153: /setarg 1 def
1154: } { } ifelse
1.15 takayama 1155: typev [ArrayP ArrayP ArrayP ArrayP] eq
1.14 takayama 1156: { /f aa 0 get def
1157: /v aa 1 get from_records def
1158: /wv aa 2 get def
1.15 takayama 1159: opt aa 3 get ecart.setOpt join /opt set
1.14 takayama 1160: /setarg 1 def
1161: } { } ifelse
1162: setarg { } { (ecart.minimalBase : Argument mismatch) error } ifelse
1163:
1164: [(KanGBmessage) ecart.gb.verbose ] system_variable
1165:
1166: f 0 get tag ArrayP eq { }
1167: { f { /tt set [ tt ] } map /f set } ifelse
1168:
1.15 takayama 1169: [f v wv [(degreeShift) degreeShift (startingShift) [hdShift 0 get degreeShift 0 get]] opt join]
1.14 takayama 1170: ecart.gb /ff set
1171: ff getRing ring_def
1172:
1173: ff 0 get { {toString } map } map /ff set
1174:
1.15 takayama 1175: [ff v wv
1176: [(degreeShift) degreeShift (startingShift) [hdShift 0 get degreeShift 0 get]] opt join
1177: ] /arg1 set
1.14 takayama 1178: ] pop
1179: popVariables
1180: arg1
1181: } def
1182: [(ecart.gen_input)
1.18 takayama 1183: [$[ff v ecart.weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]] ] ecart.gen_input $
1184: $ [gg_h v ecart.weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]]] $
1.14 takayama 1185: (It generates the input for the minimal filtered free resolution.)
1186: (Current ring is changed to the ring of gg_h.)
1187: (cf. ecart.minimalBase)
1188: $Example: [ [(t-x^3+y^2) (Dx+ 3 x^2 Dt) (Dy - 2 y Dt)] (t,x,y) $
1189: $ [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] $
1.15 takayama 1190: $ [(degreeShift) [ [0] ] $
1191: $ (startingShift) [ [0] [0] ]] ] ecart.gen_input /gg set gg pmat $
1.14 takayama 1192: ]] putUsages
1193:
1194:
1.13 takayama 1195: [(ecart.minimalBase)
1.18 takayama 1196: [$[ff v ecart.weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]]] ecart.minimalBase $
1.14 takayama 1197: ( [mbase gr_of_mbase )
1.18 takayama 1198: $ [syz v ecart.weight_vector [(degreeShift) new_uv_shift_m (startingShift) [new_D_shift_n new_uv_shift_m]]]$
1.14 takayama 1199: ( gr_of_syz ])
1200: (mbase is the minimal generators of ff in D^h in the sense of filtered minimal)
1201: (generators.)
1202: $Example: [ [(t-x^3+y^2) (Dx+ 3 x^2 Dt) (Dy - 2 y Dt)] (t,x,y) $
1203: $ [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] $
1.15 takayama 1204: $ [(degreeShift) [ [0] ] $
1205: $ (startingShift) [ [0] [0] ] ] ] ecart.gen_input /gg0 set $
1.14 takayama 1206: $ gg0 ecart.minimalBase /ss0 set $
1207: $ ss0 2 get ecart.minimalBase /ss1 set $
1208: $ ss1 2 get ecart.minimalBase /ss2 set $
1209: $ (--------- minimal filtered resolution -------) message $
1210: $ ss0 0 get pmat ss1 0 get pmat ss2 0 get pmat $
1211: $ (--------- degree shift (n,m) n:D-shift m:uv-shift -------) message $
1.15 takayama 1212: $ gg0 3 get 3 get message $
1213: $ ss0 2 get 3 get 3 get message $
1214: $ ss1 2 get 3 get 3 get message $
1215: $ ss2 2 get 3 get 3 get message ; $
1.14 takayama 1216:
1.13 takayama 1217: ]] putUsages
1218: /ecart.minimalBase {
1219: /arg1 set
1220: [/in-ecart.minimalBase /ai1 /ai /aa /typev /setarg /f /v
1221: /gg /wv /vec /ans /rr /mm
1222: /degreeShift /env2 /opt /ss0
1223: /hdShift
1224: /degreeShiftD /degreeShiftUV
1225: /degreeShiftDnew /degreeShiftUVnew
1226: /tt
1227: /ai1_gr /ai_gr
1228: /s /r /p /q /i /j /k
1229: /ai1_new /ai_new /ai_new2
1230: ] pushVariables
1231: [
1232: /aa arg1 def
1233: aa isArray { } { ( << array >> ecart.minimalBase) error } ifelse
1234: /setarg 0 def
1235: /wv 0 def
1236: /degreeShift 0 def
1237: /hdShift 0 def
1.15 takayama 1238: /opt [ ] def
1.13 takayama 1239: aa { tag } map /typev set
1.15 takayama 1240: typev [ArrayP StringP ArrayP ArrayP] eq
1.13 takayama 1241: { /f aa 0 get def
1242: /v aa 1 get def
1243: /wv aa 2 get def
1.15 takayama 1244: opt aa 3 get ecart.setOpt join /opt set
1.13 takayama 1245: /setarg 1 def
1246: } { } ifelse
1.15 takayama 1247: typev [ArrayP ArrayP ArrayP ArrayP] eq
1.13 takayama 1248: { /f aa 0 get def
1249: /v aa 1 get from_records def
1250: /wv aa 2 get def
1.15 takayama 1251: opt aa 3 get ecart.setOpt join /opt set
1.13 takayama 1252: /setarg 1 def
1253: } { } ifelse
1254: setarg { } { (ecart.minimalBase : Argument mismatch) error } ifelse
1255:
1256: [(KanGBmessage) ecart.gb.verbose ] system_variable
1257:
1258: f 0 get tag ArrayP eq { }
1259: { f { /tt set [ tt ] } map /f set } ifelse
1.15 takayama 1260: [f v wv [(degreeShift) degreeShift (noAutoHomogenize) 1] opt join] ecart.syz /ss0 set
1.13 takayama 1261:
1262: ss0 getRing ring_def
1263: /degreeShiftD hdShift 0 get def
1264: /degreeShiftUV hdShift 1 get def
1265: % -- ai --> D^r -- ai1 --> D^rr
1266: /ai1 f { { . } map } map def
1267: /ai ss0 0 get def
1268:
1269: {
1270: /degreeShiftUVnew
1271: ai1 { [ << wv 0 get weightv >> degreeShiftUV ] ord_ws_all } map
1272: def
1273: (degreeShiftUVnew=) messagen degreeShiftUVnew message
1274:
1275: /degreeShiftDnew
1276: ai1 { [ << v ecart.minimalBase.D1 weightv >> degreeShiftD ] ord_ws_all}
1277: map
1278: def
1279: (degreeShiftDnew=) messagen degreeShiftDnew message
1280:
1281: ai {[wv 0 get weightv degreeShiftUVnew] init} map /ai_gr set
1282:
1283: %C Note 2003.8.26
1284:
1.14 takayama 1285: ai [ ] eq {
1286: exit
1287: } { } ifelse
1288:
1.13 takayama 1289: /s ai length def
1290: /r ai 0 get length def
1291:
1292: /itIsMinimal 1 def
1293: 0 1 s 1 sub {
1294: /i set
1295: 0 1 r 1 sub {
1296: /j set
1297:
1298: [(isConstantAll) ai_gr i get j get] gbext
1299: ai_gr i get j get (0). eq not and
1300: {
1301: /itIsMinimal 0 def
1302: /p i def /q j def
1303: } { } ifelse
1304: } for
1305: } for
1306:
1307:
1308: itIsMinimal { exit } { } ifelse
1309:
1310: % construct new ai and ai1 (A_i and A_{i-1})
1311: /ai1_new r 1 sub newVector def
1312: /j 0 def
1313: 0 1 r 1 sub {
1314: /i set
1315: i q eq not {
1316: ai1_new j ai1 i get put
1317: /j j 1 add def
1318: } { } ifelse
1319: } for
1320:
1321: /ai_new [s r] newMatrix def
1322: 0 1 s 1 sub {
1323: /j set
1324: 0 1 r 1 sub {
1325: /k set
1326: ai_new [j k]
1327: << ai p get q get >> << ai j get k get >> mul
1328: << ai j get q get >> << ai p get k get >> mul
1329: sub
1330: put
1331: } for
1332: } for
1333:
1334: % remove 0 column
1335: /ai_new2 [s 1 sub r 1 sub] newMatrix def
1336: /j 0 def
1337: 0 1 s 1 sub {
1338: /i set
1339: i p eq not {
1340: ai_new2 j << ai_new i get q ecart.removeElem >> put
1341: /j j 1 add def
1342: } { } ifelse
1343: } for
1344:
1345: % ( ) error
1.14 takayama 1346: /ai1 ai1_new def
1347: /ai ai_new2 ecart.removeZeroRow def
1.13 takayama 1348:
1349: } loop
1.14 takayama 1350: /arg1
1351: [ ai1
1352: ai1 {[wv 0 get weightv degreeShift 0 get] init} map %Getting gr of A_{i-1}
1.15 takayama 1353: [ai v wv [(degreeShift) [degreeShiftUVnew] (startingShift) [degreeShiftDnew degreeShiftUVnew]]]
1.14 takayama 1354: ai {[wv 0 get weightv degreeShiftUVnew] init} map %Getting gr of A_i
1355: ]
1356: def
1.13 takayama 1357: ] pop
1358: popVariables
1359: arg1
1360: } def
1361:
1.15 takayama 1362: /ecart.minimalResol {
1363: /arg1 set
1364: [/in-ecart.minimalResol /aa /ans /gg0 /ansds /ans_gr /c] pushVariables
1365: [
1366: /aa arg1 def
1367: /ans [ ] def
1368: /ansds [ ] def
1369: /ans_gr [ ] def
1370: /c 0 def
1371:
1372: (---- ecart.gen_input ----) message
1373: aa ecart.gen_input /gg0 set
1374: ansds gg0 3 get 3 get append /ansds set
1375: (---- ecart.minimalBase --- Degree ) messagen c message c 1 add /c set
1376: gg0 ecart.minimalBase /ssi set
1377: ansds ssi 2 get 3 get 3 get append /ansds set
1378: ans ssi 0 get append /ans set
1379: ans_gr ssi 1 get append /ans_gr set
1380: {
1381: ssi 3 get [ ] eq { exit } { } ifelse
1382: (---- ecart.minimalBase --- Degree ) messagen c message c 1 add /c set
1383: ssi 2 get ecart.minimalBase /ssi_new set
1384: ans ssi_new 0 get append /ans set
1385: ansds ssi_new 2 get 3 get 3 get append /ansds set
1386: ans_gr ssi_new 1 get append /ans_gr set
1387: /ssi ssi_new def
1388: } loop
1389: /arg1 [ans ansds ans_gr] def
1390: ] pop
1391: popVariables
1392: arg1
1393: } def
1394:
1395: (ecart.minimalResol) message
1396:
1397: [(ecart.minimalResol)
1398: [
1399:
1.18 takayama 1400: $[ff v ecart.weight_vector [(degreeShift) uv_shift_m (startingShift) [D_shift_n uv_shift_m]]] ecart.minimalResol $
1.15 takayama 1401: ( [resol degree_shifts gr_of_resol_by_uv_shift_m] )
1402: $Example1: [ [(t-x^3+y^2) (Dx+ 3 x^2 Dt) (Dy - 2 y Dt)] (t,x,y) $
1403: $ [ [(t) -1 (Dt) 1] [(t) -1 (x) -1 (y) -1 (Dt) 1 (Dx) 1 (Dy) 1]] $
1404: $ [(degreeShift) [ [0] ] $
1405: $ (startingShift) [ [0] [0] ] ] ] ecart.minimalResol /gg set gg pmat $
1406: ]] putUsages
1.18 takayama 1407:
1408: %% for ecart.weight_vector
1409: /ecart.eliminationOrderTemplate { %% esize >= 1
1410: %% if esize == 0, it returns reverse lexicographic order.
1411: %% m esize eliminationOrderTemplate mat
1412: /arg2 set /arg1 set
1413: [/m /esize /m1 /m2 /k /om /omtmp] pushVariables
1414: [
1415: /m arg1 def /esize arg2 def
1416: /m1 m esize sub 1 sub def
1417: /m2 esize 1 sub def
1418: [esize 0 gt
1419: {
1420: [1 1 esize
1421: { pop 1 } for
1422: esize 1 << m 1 sub >>
1423: { pop 0 } for
1424: ] %% 1st vector
1425: }
1426: { } ifelse
1427:
1428: m esize gt
1429: {
1430: [1 1 esize
1431: { pop 0 } for
1432: esize 1 << m 1 sub >>
1433: { pop 1 } for
1434: ] %% 2nd vector
1435: }
1436: { } ifelse
1437:
1438: m1 0 gt
1439: {
1440: m 1 sub -1 << m m1 sub >>
1441: {
1442: /k set
1443: m k evec_neg
1444: } for
1445: }
1446: { } ifelse
1447:
1448: m2 0 gt
1449: {
1450: << esize 1 sub >> -1 1
1451: {
1452: /k set
1453: m k evec_neg
1454: } for
1455: }
1456: { } ifelse
1457:
1458: ] /om set
1459: om [ 0 << m 2 idiv >> 1 sub] 0 put
1460: om [ << m 2 idiv >> 1 add << m 2 idiv >> 1 sub] 0 put
1461: /arg1 om def
1462: ] pop
1463: popVariables
1464: arg1
1465: } def
1466:
1467: %note 2003.09.29
1468: /ecart.elimination_order {
1469: %% [x-list d-list params] (x,y,z) elimination_order
1470: %% vars evars
1471: %% [x-list d-list params order]
1472: /arg2 set /arg1 set
1473: [/vars /evars /univ /order /perm /univ0 /compl /m /omtmp] pushVariables
1474: /vars arg1 def /evars [arg2 to_records pop] def
1475: [
1476: /univ vars 0 get reverse
1477: vars 1 get reverse join
1478: def
1479:
1480: << univ length 2 sub >>
1481: << evars length >>
1482: ecart.eliminationOrderTemplate /order set
1483:
1484: [[1]] order oplus [[1]] oplus /order set
1485:
1486: /m order length 2 sub def
1487: /omtmp [1 1 m 2 add { pop 0 } for ] def
1488: omtmp << m 2 idiv >> 1 put
1489: order omtmp append /order set
1490: % order pmat
1491:
1492: /univ0 [univ reverse aload pop pop] reverse def %% [e,x,y,h] --> [x,y,h]
1493:
1494: /compl
1495: [univ 0 get] evars join evars univ0 complement join
1496: def
1497: compl univ
1498: getPerm /perm set
1499: %%perm :: univ :: compl ::
1500:
1501: order perm permuteOrderMatrix /order set
1502:
1503:
1504: vars [order] join /arg1 set
1505: ] pop
1506: popVariables
1507: arg1
1508: } def
1509:
1510: /ecart.define_ring {
1511: /arg1 set
1512: [/rp /param /foo] pushVariables
1513: [/rp arg1 def
1514:
1515: rp 0 get length 3 eq {
1516: rp 0 [rp 0 get 0 get rp 0 get 1 get rp 0 get 2 get ]
1517: ( ) ecart.elimination_order put
1518: } { } ifelse
1519:
1520: [
1521: rp 0 get 0 get %% x-list
1522: rp 0 get 1 get %% d-list
1523: rp 0 get 2 get /param set
1524: param 0 << rp 1 get >> put %% << rp 1 get >> is 17 in the example.
1525: param %% parameters.
1526: rp 0 get 3 get %% order matrix.
1527: rp length 2 eq
1528: { [ ] } %% null optional argument.
1529: { rp 2 get }
1530: ifelse
1531: ] /foo set
1532: foo aload pop set_up_ring@
1533: ] pop
1534: popVariables
1535: [(CurrentRingp)] system_variable
1536: } def
1537: /ecart.weight_vector {
1538: /arg2 set /arg1 set
1539: [/vars /univ /w-vectors /www /k /order1 /order2] pushVariables
1540: /vars arg1 def /w-vectors arg2 def
1541: [
1542: /univ vars 0 get reverse
1543: vars 1 get reverse join
1544: def
1545: [
1546: 0 1 << w-vectors length 1 sub >>
1547: {
1548: /k set
1549: univ w-vectors k get w_to_vec
1550: } for
1551: ] /order1 set
1552: %% order1 ::
1553:
1554: vars ( ) ecart.elimination_order 3 get /order2 set
1555: vars [ << order1 order2 join >> ] join /arg1 set
1556: ] pop
1557: popVariables
1558: arg1
1559: } def
1560:
1561: %% end of for ecart.define_ring
1.19 takayama 1562:
1563: /ecartd.reduction {
1564: /arg2 set
1565: /arg1 set
1566: [/in-ecartd.reduction /gbasis /flist /ans /gbasis2] pushVariables
1567: [(CurrentRingp) (KanGBmessage)] pushEnv
1568: [
1569: /gbasis arg2 def
1570: /flist arg1 def
1571: gbasis 0 get tag 6 eq { }
1572: { (ecartd.reduction: the second argument must be a list of lists) error }
1573: ifelse
1574:
1575: gbasis length 1 eq {
1576: gbasis getRing ring_def
1577: /gbasis2 gbasis 0 get def
1578: } {
1579: [ [(1)] ] gbasis rest join ecartd.gb 0 get getRing ring_def
1580: /gbasis2 gbasis 0 get ,,, def
1581: } ifelse
1582: ecartd.begin
1583:
1584: flist ,,, /flist set
1585: flist tag 6 eq {
1586: flist { gbasis2 reduction } map /ans set
1587: }{
1588: flist gbasis2 reduction /ans set
1589: } ifelse
1590: /arg1 ans def
1591:
1592: ecartd.end
1593: ] pop
1594: popEnv
1595: popVariables
1596: arg1
1597: } def
1598:
1599: /ecartd.reduction.test {
1600: [
1601: [( 2*(1-x-y) Dx + 1 ) ( 2*(1-x-y) Dy + 1 )]
1602: (x,y) [[(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]]]
1603: ecartd.gb /gg set
1604:
1605: (Dx) [gg 0 get] ecartd.reduction /gg2 set
1606: gg2 message
1607: (-----------------------------) message
1608:
1609: [(Dx) (Dy) (Dx+x*Dy)] [gg 0 get] ecartd.reduction /gg3 set
1610: gg3 message
1611:
1612: (-----------------------------) message
1613: [[( 2*(1-x-y) Dx + h ) ( 2*(1-x-y) Dy + h )]
1614: (x,y) [[(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]]] /ggg set
1615: (Dx) ggg ecartd.reduction /gg4 set
1616: gg4 message
1617: [gg2 gg3 gg4]
1618: } def
1619:
1620: /ecarth.reduction {
1621: /arg2 set
1622: /arg1 set
1623: [/in-ecarth.reduction /gbasis /flist /ans /gbasis2] pushVariables
1624: [(CurrentRingp) (KanGBmessage)] pushEnv
1625: [
1626: /gbasis arg2 def
1627: /flist arg1 def
1628: gbasis 0 get tag 6 eq { }
1629: { (ecarth.reduction: the second argument must be a list of lists) error }
1630: ifelse
1631:
1632: gbasis length 1 eq {
1633: gbasis getRing ring_def
1634: /gbasis2 gbasis 0 get def
1635: } {
1636: [ [(1)] ] gbasis rest join ecarth.gb 0 get getRing ring_def
1637: /gbasis2 gbasis 0 get ,,, def
1638: } ifelse
1639: ecarth.begin
1640:
1641: flist ,,, /flist set
1642: flist tag 6 eq {
1643: flist { gbasis2 reduction } map /ans set
1644: }{
1645: flist gbasis2 reduction /ans set
1646: } ifelse
1647: /arg1 ans def
1648:
1649: ecarth.end
1650: ] pop
1651: popEnv
1652: popVariables
1653: arg1
1654: } def
1655:
1656: [(ecartd.reduction)
1657: [ (f basis ecartd.reduction r)
1658: (f is reduced by basis by the tangent cone algorithm.)
1.20 takayama 1659: (The first element of basis <g_1,...,g_m> must be a standard basis.)
1.19 takayama 1660: (r is the return value format of reduction.)
1.20 takayama 1661: (r=[h,c0,syz,input], h = c0 f + \sum syz_i g_i)
1662: (basis is given in the argument format of ecartd.gb.)
1.21 ! takayama 1663: $h[0,1](D)-homogenization is used.$
1.19 takayama 1664: (cf. reduction, ecartd.gb, ecartd.reduction.test )
1665: $Example:$
1666: $ [[( 2*(1-x-y) Dx + h ) ( 2*(1-x-y) Dy + h )] $
1667: $ (x,y) [[(Dx) 1 (Dy) 1] [(x) -1 (y) -1 (Dx) 1 (Dy) 1]]] /ggg set $
1668: $ (Dx+Dy) ggg ecartd.reduction :: $
1669: ]] putUsages
1.18 takayama 1670:
1.5 takayama 1671:
1.2 takayama 1672: ( ) message-quiet
1.5 takayama 1673:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ecart.sm1 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Doc