Annotation of OpenXM/src/kan96xx/Doc/resol0.sm1, Revision 1.1
1.1 ! maekawa 1: %% lib/resol0.sm1, 1998, 11/8, 11/14, 1999, 05/18
! 2: %% cf. r-interface.sm1, tower.sm1, tower-sugar.sm1
! 3: %%
! 4: %% It must contain one-line command for resolution.
! 5: /resol0.verbose 0 def
! 6: /resol0.parse 0 def %% If 1,
! 7: %%Output of resol1 will be in a regular (non-schreyer) ring.
! 8: %% tower or tower-sugar will be chosen by the global variable
! 9: %% resol0.cp --- resol0 context pointer.
! 10: /resol0.version (2.981114) def
! 11: resol0.version [(Version)] system_variable gt
! 12: { (This package requires the latest version of kan/sm1) message
! 13: (Please get it from http://www.math.kobe-u.ac.jp/KAN) message
! 14: error
! 15: } { } ifelse
! 16:
! 17: $resol0.sm1, package to construct schreyer resolutions -- not minimal $ message-quiet
! 18: $ (C) N.Takayama, 1999, 5/18. resol0, resol1 $
! 19: message-quiet
! 20:
! 21: resol0.verbose {
! 22: (Loading tower.sm1 in the context Tower and) message
! 23: (loading tower-sugar.sm1 in the context Tower-sugar.) message
! 24: } { } ifelse
! 25:
! 26: (Tower) StandardContextp newcontext /cp.Tower set
! 27: cp.Tower setcontext
! 28: [(parse) (tower.sm1) pushfile] extension pop
! 29: StandardContextp setcontext
! 30:
! 31: (Tower-sugar) StandardContextp newcontext /cp.Tower-sugar set
! 32: cp.Tower-sugar setcontext
! 33: [(parse) (tower-sugar.sm1) pushfile] extension pop
! 34: StandardContextp setcontext
! 35:
! 36: /resol0.cp cp.Tower def
! 37: /resol0.v [(x) (y) (z)] def
! 38: /resol0 {
! 39: /arg1 set
! 40: [/in-resol0 /aa /typev /setarg /f /v
! 41: /gg /wv /vec /ans /depth
! 42: ] pushVariables
! 43: [(CurrentRingp) (KanGBmessage)] pushEnv
! 44: [
! 45: /aa arg1 def
! 46: aa isArray { } { (array gb) message (resol0) usage error } ifelse
! 47: aa length 0 { (resol0) usage error } { } ifelse
! 48: aa 0 get isInteger {
! 49: aa 0 get /depth set
! 50: aa rest /aa set
! 51: }
! 52: { /depth [ ] def } ifelse
! 53:
! 54: /setarg 0 def
! 55: /wv [ ] def
! 56: aa { tag } map /typev set
! 57: typev [ ArrayP ] eq
! 58: { /f aa 0 get def
! 59: /v resol0.v def
! 60: /setarg 1 def
! 61: } { } ifelse
! 62: typev [ArrayP StringP] eq
! 63: { /f aa 0 get def
! 64: /v aa 1 get def
! 65: /setarg 1 def
! 66: } { } ifelse
! 67: typev [ArrayP ArrayP] eq
! 68: { /f aa 0 get def
! 69: /v aa 1 get from_records def
! 70: /setarg 1 def
! 71: } { } ifelse
! 72: typev [ArrayP StringP ArrayP] eq
! 73: { /f aa 0 get def
! 74: /v aa 1 get def
! 75: /wv aa 2 get def
! 76: /setarg 1 def
! 77: } { } ifelse
! 78: typev [ArrayP ArrayP ArrayP] eq
! 79: { /f aa 0 get def
! 80: /v aa 1 get from_records def
! 81: /wv aa 2 get def
! 82: /setarg 1 def
! 83: } { } ifelse
! 84:
! 85: setarg { } { (resol0 : Argument mismatch) message error } ifelse
! 86:
! 87: [(KanGBmessage) resol0.verbose ] system_variable
! 88: f 0 get isArray {
! 89: [v ring_of_differential_operators 0] define_ring
! 90: f { {toString .} map } map /f set
! 91: }{
! 92: f {toString} map /f set
! 93: } ifelse
! 94:
! 95: [resol0.cp v wv ] {tower.define_sring} sendmsg
! 96: [resol0.cp f ] {tower.tparse-vec} sendmsg /gg set
! 97: [resol0.cp depth gg] {tower.sResolution} sendmsg /ans set
! 98: /arg1 ans def
! 99: ] pop
! 100: popEnv
! 101: popVariables
! 102: arg1
! 103: } def
! 104: [(resol0)
! 105: [( [ ii v] resol0 r )
! 106: (array of poly ii; string v;)
! 107: (<< vv >> is a string of variables separated by ,)
! 108: ( )
! 109: ( [ ii v] resol0 r )
! 110: (array of poly ii; array of strings v;)
! 111: (<< vv >> is an array of variable names. )
! 112: ( )
! 113: ( [ ii v w] resol0 r )
! 114: (array of poly ii; string v; array w;)
! 115: (<< w >> is a weight vector.)
! 116: ( )
! 117: (You can also give a parameter << d >> to specify the truncation depth)
! 118: (of the resolution: [ d ii v] resol0, [d ii v w] resol0)
! 119: ( )
! 120: (resol0 constructs a resolution which is adapted (strict))
! 121: (to a filtration. So, it is not minimal.)
! 122: ( r = [starting Groebner basis g, [ s1, s2 , s3, ...], order-def].)
! 123: (g is the reduced Groebner basis for f, )
! 124: ( s1 is the syzygy of g,)
! 125: ( s2 is the syzygy of s1,)
! 126: ( s3 is the syzygy of s2 and so on.)
! 127: (For details, see math.AG/9805006)
! 128: (cf. sResolution, tparse, s_ring_..., resol0.cp)
! 129: (Example: [ [( x^3-y^2 ) ( 2 x Dx + 3 y Dy + 6 ) ( 2 y Dx + 3 x^2 Dy) ] )
! 130: ( (x,y) ] resol0 :: )
! 131: ]] putUsages
! 132:
! 133: /resol1 {
! 134: /arg1 set
! 135: [/in-resol1 /aa /typev /setarg /f /v
! 136: /gg /wv /vec /ans /depth /vectorInput
! 137: /vsize /eVector /ii /syzlist /syzlist1 /syz0 /i
! 138: ] pushVariables
! 139: [(CurrentRingp) (KanGBmessage)] pushEnv
! 140: [
! 141: /aa arg1 def
! 142: aa isArray { } { (array gb) message (resol1) usage error } ifelse
! 143: aa length 0 { (resol1) usage error } { } ifelse
! 144: aa 0 get isInteger {
! 145: aa 0 get /depth set
! 146: aa rest /aa set
! 147: }
! 148: { /depth [ ] def } ifelse
! 149:
! 150: /setarg 0 def
! 151: /wv [ ] def
! 152: aa { tag } map /typev set
! 153: typev [ ArrayP ] eq
! 154: { /f aa 0 get def
! 155: /v resol0.v def
! 156: /setarg 1 def
! 157: } { } ifelse
! 158: typev [ArrayP StringP] eq
! 159: { /f aa 0 get def
! 160: /v aa 1 get def
! 161: /setarg 1 def
! 162: } { } ifelse
! 163: typev [ArrayP ArrayP] eq
! 164: { /f aa 0 get def
! 165: /v aa 1 get from_records def
! 166: /setarg 1 def
! 167: } { } ifelse
! 168: typev [ArrayP StringP ArrayP] eq
! 169: { /f aa 0 get def
! 170: /v aa 1 get def
! 171: /wv aa 2 get def
! 172: /setarg 1 def
! 173: } { } ifelse
! 174: typev [ArrayP ArrayP ArrayP] eq
! 175: { /f aa 0 get def
! 176: /v aa 1 get from_records def
! 177: /wv aa 2 get def
! 178: /setarg 1 def
! 179: } { } ifelse
! 180:
! 181: setarg { } { (resol1 : Argument mismatch) message error } ifelse
! 182:
! 183: [(KanGBmessage) resol0.verbose ] system_variable
! 184: f 0 get isArray {
! 185: /vectorInput 1 def
! 186: /vsize f 0 get length def
! 187: } {
! 188: /vsize 1 def
! 189: /vectorInput 0 def
! 190: }ifelse
! 191:
! 192: vectorInput {
! 193: [v ring_of_differential_operators 0] define_ring
! 194: %% /eVector [0 1 vsize 1 sub { /ii set @@@.esymbol . ii npower } for ] def
! 195: %% f { {toString .} map eVector mul toString } map /f set
! 196: %%Now, sResolution in tower.sm1 accept vector input, 1999, 5/18.
! 197: f { {toString .} map } map /f set
! 198: }{
! 199: f {toString} map /f set
! 200: } ifelse
! 201:
! 202: [resol0.cp v wv ] {tower.define_sring} sendmsg
! 203: [resol0.cp f ] {tower.tparse-vec} sendmsg /gg set
! 204: resol0.verbose { gg message } { } ifelse
! 205: [resol0.cp depth gg] {tower.sResolution} sendmsg /syzlist set
! 206:
! 207: /resol1.syzlist syzlist def %% save in the global variable.
! 208: %% From restall_s.sm1
! 209: %% Reformatting the free resolution:
! 210: %% [[f1,f2,..],[syz1,...]] --> [[[f1],[f2],...],[syz,...]]
! 211: %% (to be modified for the case with more than one unknowns.)
! 212: [v ring_of_differential_operators 0] define_ring
! 213: /degmax syzlist 1 get length def
! 214: /syzlist1 [
! 215: syzlist 0 get /syz0 set
! 216: %% start N.T.
! 217: resol0.parse {
! 218: [vsize syz0 { toString . } map]
! 219: } { [vsize syz0 ] } ifelse
! 220: toVectors2
! 221: %% end N.T.
! 222: 1 1 degmax {/i set
! 223: resol0.parse {
! 224: syzlist 1 get i 1 sub get {{toString .} map } map
! 225: }{ syzlist 1 get i 1 sub get } ifelse
! 226: } for
! 227: ] def
! 228: syzlist1
! 229: /syzlist set
! 230:
! 231: /arg1 syzlist def
! 232: ] pop
! 233: popEnv
! 234: popVariables
! 235: arg1
! 236: } def
! 237: [(resol1)
! 238: [( [ ii v] resol1 r )
! 239: (array of poly ii; string v;)
! 240: (<< vv >> is a string of variables separated by ,)
! 241: ( )
! 242: ( [ ii v] resol1 r )
! 243: (array of poly ii; array of strings v;)
! 244: (<< vv >> is an array of variable names. )
! 245: ( )
! 246: ( [ ii v w] resol1 r )
! 247: (array of poly ii; string v; array w;)
! 248: (<< w >> is a weight vector.)
! 249: ( )
! 250: ( ii may be array of array of poly.)
! 251: (You can also give a parameter << d >> to specify the truncation depth)
! 252: (of the resolution: [ d ii v] resol1, [d ii v w] resol1)
! 253: ( )
! 254: (resol1 constructs a resolution which is adapted (strict))
! 255: (to a filtration. So, it is not minimal in general.)
! 256: ( r = [s0, s1, s2 , s3, ...].)
! 257: ( s0 is the groebner basis of ii,)
! 258: ( s1 is the syzygy of s0,)
! 259: ( s2 is the syzygy of s1,)
! 260: ( s3 is the syzygy of s2 and so on.)
! 261: ( s1 s0 mul ==> 0, s2 s1 mul ==>0, ...)
! 262: (For details, see math.AG/9805006)
! 263: (cf. sResolution, tparse, s_ring_..., resol0.cp)
! 264: (resol1.withZeroMap returns a resolution with zero maps of the both sides)
! 265: ( of the resolution.)
! 266: (cf. resol1.zeroMapL, resol1.zeroMapR, resol1.withZeroMap.aux)
! 267: (resol1.syzlist : global variable to keep the raw output of sResolution.)
! 268: ( )
! 269: (Example 1: [ [( x^3-y^2 ) ( 2 x Dx + 3 y Dy + 6 ) ( 2 y Dx + 3 x^2 Dy) ] )
! 270: ( (x,y) ] resol1 pmat ; )
! 271: (Example 2: [ [( x^3-y^2 ) ( 2 x Dx + 3 y Dy + 6 ) ( 2 y Dx + 3 x^2 Dy) ] )
! 272: ( (x,y) [[(x) -1 (Dx) 1 (y) -1 (Dy) 1]]] resol1 pmat ; )
! 273: (Example 3: [ [[(2 x Dx + 3 y Dy +6) (0)] )
! 274: ( [(3 x^2 Dy + 2 y Dx) (0)] )
! 275: ( [(0) (x^2+y^2)] )
! 276: ( [(0) (x y )] ] )
! 277: ( (x,y) [[(x) -1 (Dx) 1 (y) -1 (Dy) 1]]] resol1 pmat ; )
! 278: (Example 4: /resol0.verbose 1 def)
! 279: $ [ [[(x^2+y^2+ x y) (x+y)] [(x y ) ( x^2 + x y^3)] ] (x,y) $
! 280: $ [[(x) -1 (Dx) 1 (y) -1 (Dy) 1]]] resol1 pmat ; $
! 281: ]] putUsages
! 282:
! 283: /resol1.withZeroMap {
! 284: resol1 resol1.withZeroMap.aux
! 285: } def
! 286: /resol1.withZeroMap.aux {
! 287: /arg1 set
! 288: [/in-resol1.withZeroMap.aux /ss /nn /mm] pushVariables
! 289: [
! 290: /ss arg1 def
! 291: ss 0 get length /mm set
! 292: ss 0 get 0 get isArray {
! 293: /nn ss 0 get 0 get length def
! 294: } { /nn 1 def } ifelse
! 295: [ [nn mm] resol1.zeroMapR]
! 296: ss join
! 297: /ss set
! 298:
! 299: ss ss length 1 sub get [ ] eq {
! 300: ss << ss length 1 sub >>
! 301: << ss << ss length 2 sub >> get >> length resol1.zeroMapL put
! 302: } { } ifelse
! 303: /arg1 ss def
! 304: ] pop
! 305: popVariables
! 306: arg1
! 307: } def
! 308:
! 309: /resol1.zeroMapR {
! 310: %% [[0,0],
! 311: %% [0,0],
! 312: %% [0,0]]
! 313: /arg1 set
! 314: [/in-resol1.zeroMapR /mm /nn] pushVariables
! 315: [
! 316: /mm arg1 0 get def
! 317: /nn arg1 1 get def
! 318: [ 1 1 mm { pop [1 1 nn { pop (0).} for] } for ]
! 319: /arg1 set
! 320: ] pop
! 321: popVariables
! 322: arg1
! 323: } def
! 324: /resol1.zeroMapL {
! 325: %% [[0,0,0]]
! 326: /arg1 set
! 327: [/in-resol1.zeroMapL /mm ] pushVariables
! 328: [
! 329: /mm arg1 def
! 330: [ [1 1 mm { pop (0). } for ]]
! 331: /arg1 set
! 332: ] pop
! 333: popVariables
! 334: arg1
! 335: } def
! 336:
! 337: /pres1 {
! 338: /arg1 set
! 339: [/in-pres1 /rr /i /nn] pushVariables
! 340: [
! 341: /rr arg1 def
! 342: /nn rr length 1 sub def
! 343: 0 1 nn {
! 344: /i set
! 345: rr i get [ ] eq { /pres1.LLL goto } { } ifelse
! 346: (k^) messagen rr i get 0 get length message
! 347: (^) message
! 348: (|) message
! 349: rr i get pmat
! 350: (|) message
! 351: } for
! 352: /pres1.LLL
! 353: ] pop
! 354: popVariables
! 355: arg1
! 356: } def
! 357: [(pres1)
! 358: [(rr pres1)
! 359: (print resolution rr.)
! 360: $Example $
! 361: $ [ [[(x^2+y^2+ x y) (x+y)] [(x y ) ( x^2 + x y^3)] ] (x,y) $
! 362: $ [[(x) -1 (Dx) 1 (y) -1 (Dy) 1]]] resol1.withZeroMap pres1 ; $
! 363: ]] putUsages
! 364:
! 365:
! 366:
! 367: %% It is included to work on the older version. It may removed.
! 368: %% toVectors2 is already in dr.sm1
! 369: (2.990500) [(Version)] system_variable gt
! 370: {
! 371: /toVectors2 {
! 372: /arg1 set
! 373: [/in-toVectors2 /gg /ans /n /tmp] pushVariables
! 374: [
! 375: /gg arg1 def
! 376: /ans gg 1 get toVectors def
! 377: /n gg 0 get def
! 378: ans {
! 379: /tmp set
! 380: tmp length n lt {
! 381: tmp
! 382: [1 1 n tmp length sub { pop (0). } for ]
! 383: join /tmp set
! 384: } { } ifelse
! 385: tmp
! 386: } map
! 387: /ans set
! 388: /arg1 ans def
! 389: ] pop
! 390: popVariables
! 391: arg1
! 392: } def
! 393: } { } ifelse
! 394:
! 395: resol0.cp setcontext
! 396: /tower.define_sring {
! 397: /arg1 set
! 398: [/in-tower.define_sring /vv /ww /r] pushVariables
! 399: [
! 400: /vv arg1 1 get def
! 401: /ww arg1 2 get def
! 402: ww [ ] eq {
! 403: [vv s_ring_of_differential_operators 0 [(schreyer) 1]] define_ring
! 404: } {
! 405: [vv s_ring_of_differential_operators ww s_weight_vector
! 406: 0 [(schreyer) 1]] define_ring
! 407: } ifelse
! 408: /r set
! 409: /arg1 r def
! 410: ] pop
! 411: popVariables
! 412: arg1
! 413: } def
! 414:
! 415: /tower.tparse-vec {
! 416: /arg1 set
! 417: [/in-tower.tparse-vec /ff ] pushVariables
! 418: [
! 419: arg1 1 get /ff set
! 420: ff 0 get isArray {
! 421: ff {{tparse} map} map /ff set
! 422: } {
! 423: ff {tparse} map /ff set
! 424: } ifelse
! 425: /arg1 ff def
! 426: ] pop
! 427: popVariables
! 428: arg1
! 429: } def
! 430:
! 431: /tower.sResolution {
! 432: resol0.verbose {
! 433: /tower.verbose 1 def
! 434: } { } ifelse
! 435: rest aload pop sResolution
! 436: } def
! 437: StandardContextp setcontext
! 438:
! 439: /test00 {
! 440: /resol0.verbose 1 def
! 441: [ [[(x^2+y^2+ x y) (x+y)] [(x y ) ( x^2 + x y^3)] ] (x,y) [[(x) -1 (Dx) 1 (y) -1 (Dy) 1]]] resol1 /ff set
! 442: } def
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to resol0.sm1 CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Doc