Changeset f0df61e in git
 Timestamp:
 Dec 11, 2000, 3:26:43 PM (23 years ago)
 Branches:
 (u'spielwiese', '91fdef05f09f54b8d58d92a472e9c4a43aa4656f')
 Children:
 1ed86cb72e1ab73da24e5b2690e172addcdc93f7
 Parents:
 bde46a274a10e7a9dd0db93b7814c2ebaae0af74
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

Singular/LIB/reesclos.lib
rbde46a rf0df61e 3 3 /////////////////////////////////////////////////////////////////////////////// 4 4 5 version="$id reesclos.lib,v 1. 28 2000/10/19hirsch Exp $";5 version="$id reesclos.lib,v 1.30 2000/12/5 hirsch Exp $"; 6 6 7 7 info=" 8 8 LIBRARY: reesclos.lib 9 AUTHOR: Tobias Hirsch, email: hirsch@mathematik.unikl.de 10 PROCEDURES: ReesAlgebra  computes the Rees Algebra of an ideal 11 NormalI  computes the integral closure of an ideal using its 12 Rees Algebra 9 AUTHOR: Tobias Hirsch, email: hirsch@math.tucottbus.de 10 11 OVERVIEW: 12 A library to compute the integral closure of an ideal I in a polynomial ring 13 R=k[x(1),...,x(n)] using the Rees Algebra R[It] of I. It computes the integral 14 closure of R[It] (in the same manner as done in the library 'normal.lib'); 15 which is a graded subalgebra of R[t]. The degreekcomponent is the integral 16 closure of the kth power of I. 17 18 PROCEDURES: 19 ReesAlgebra(I); computes the Rees Algebra of an ideal I 20 NormalI(I[,p[,r]]); computes the integral closure of an ideal I using R[It] 13 21 "; 14 22 15 LIB "normal.lib"; // for HomJJ 23 LIB "normal.lib"; // for HomJJ 24 LIB "standard.lib"; // for groebner 16 25 17 26 /////////////////////////////////////////////////////////////////////////////// 18 27 19 28 proc ReesAlgebra (ideal I) 20 "USAGE: ReesAlgebra (I); I = ideal29 "USAGE: ReesAlgebra (I); I = ideal 21 30 COMPUTE: The Rees algebra R[I*t] as an affine ring, where I is an ideal in R 22 31 RETURN: a list containing two rings: … … 36 45 ideal m = maxideal(1); 37 46 38 47 39 48 // Create a new ring with variables for each generator of I 40 49 41 50 execute ("ring Rees = "+oldchar+",("+oldvar+",U(1.."+string(n)+")),dp"); 42 51 43 52 44 53 // Kxt is the old ring with additional variable t 45 54 // Here I > t*I, so the generators of I generate the subalgebra R[It] in Kxt … … 51 60 for (k=1;k<=n;k++) 52 61 { 53 I[k]=t*I[k]; 54 } 55 62 I[k]=t*I[k]; 63 } 64 56 65 57 66 // Now we map from Rees to Kxt, identity on the original variables, and … … 68 77 ideal ker = preimage(Kxt,phi,zero); 69 78 export (ker); 70 79 71 80 list result = Rees,Kxt; 72 81 73 82 return(result); 74 83 75 84 } 76 85 example 77 86 { 87 "EXAMPLE:"; echo=2; 78 88 ring R = 0,(x,y),dp; 79 89 ideal I = x2,xy4,y5; … … 84 94 ker; // R[I*t] is isomorphic to Rees/ker 85 95 } 86 96 87 97 88 98 //////////////////////////////////////////////////////////////////////////// … … 90 100 static 91 101 proc ClosureRees (list L) 92 "USAGE: ClosureRees (L); L a list containing93  a ring L[1], inside L[1] an ideal ker such that L[1]/ker is 102 "USAGE: ClosureRees (L); L a list containing 103  a ring L[1], inside L[1] an ideal ker such that L[1]/ker is 94 104 isomorphic to the Rees Algebra R[It] of an ideal I in k[x] 95 105  a ring L[2]=k[x,t], inside L[1] an ideal mapI defining the 96 106 map L[1] > L[2] with image R[It] 97 107 COMPUTE: quotients of elements of k[x,t] representing generators of the 98 integral closure of R[It] 108 integral closure of R[It] 99 109 RETURN: a list images, the first size(images)1 entries are the nu 100 110 merators of the generators, the last one is the universal deno … … 102 112 " 103 113 { 104 int dblvl=printlevelvoice+2; // toggles how much data is printed 114 int dblvl=printlevelvoice+2; // toggles how much data is printed 105 115 // during the procedure 106 116 … … 126 136 { 127 137 "// STEP 1: Compute the integral closure of R[It]"; 128 } 138 } 129 139 130 140 list RS; … … 176 186 list JM=groebner(sin),sin; 177 187 } 178 188 179 189 if (dim(JM[1])==0 && homog(SM[2])==1) 180 190 { 181 191 isIsoSing=1; 182 192 } 183 J=equiRadical(JM[2]); 193 J=equiRadical(JM[2]); 184 194 } 185 195 else … … 194 204 } 195 205 } 196 206 197 207 if (dblvl>0) 198 208 { … … 204 214 JM =J,J; 205 215 poly nzd=SL[1]; // universal denominator for HomJJ 206 216 207 217 if (dblvl>0) 208 218 { … … 228 238 { // ring R(i+1) 229 239 ideal MJ=JM[2]; 230 231 def R(i+1)=RS[1]; // the data of and some variable decla 240 241 def R(i+1)=RS[1]; // the data of and some variable decla 232 242 setring R(i+1); // rations in R(i+1) needed in STEP 2 233 243 ideal ker(i+1)=endid; … … 237 247 if (isIsoSing==0) // fetch the singular locus if it is not 238 248 { // an isolated singularity 239 list JM=mstd(simplify(phi(MJ)+ker(i+1),4)); 249 list JM=mstd(simplify(phi(MJ)+ker(i+1),4)); 240 250 } 241 251 i++; … … 245 255 if (i==1) // R[It] (and thus I) was integrally 246 256 { // closed ==> we're already done 247 list result="closed";248 return(result);257 list result="closed"; 258 return(result); 249 259 } 250 260 … … 261 271 list preimages; // here the fractions are stored in the 262 272 // form var(j)=preimages[j]/preimages[length+1] 263 // ('=' means identification via the inclusion) 273 // ('=' means identification via the inclusion) 264 274 // the last entry corresponds to nzd in R(i) 265 275 … … 291 301 for (k=i;k>1;k) 292 302 { 293 // clear the fraction in the representation in R(i) 294 295 p=p*phi(nzd); 303 // clear the fraction in the representation in R(i) 304 305 p=p*phi(nzd); 296 306 297 307 // compute the preimage of [p mod ker(k)] under phi in R(k1): … … 302 312 // compute this normal form h... 303 313 304 if (j==1) // in the first iteration: construct S(k)=R(k)[Z], fetch 314 if (j==1) // in the first iteration: construct S(k)=R(k)[Z], fetch 305 315 // endphi (the ideal defining phi) and ker(k) and construct 306 316 // the ideal from above 307 317 { 308 execute ("ring S(k) = "+charstr(R(k))+",("+varstr(R(k))+",Z(1.." 309 +string(ncols(endphi))+")),(dp("+string(nvars(R(k))) 310 +"),dp("+string(ncols(endphi))+"));"); 318 execute ("ring S(k) = "+charstr(R(k))+",("+varstr(R(k))+",Z(1.."+string(ncols(endphi))+")),(dp("+string(nvars(R(k)))+"),dp("+string(ncols(endphi))+"));"); 311 319 ideal endphi = imap(R(k),endphi); 312 320 ideal J = imap(R(k),ker(k)); … … 324 332 } 325 333 326 // and compute h(vars(R(k1)))334 // and compute h(vars(R(k1))) 327 335 328 336 setring R(k1); … … 358 366 359 367 // at the end: go back to the original basering and construct gene 360 // rators of the closure of I 368 // rators of the closure of I 361 369 362 370 setring Kxt; 363 371 map psi=R(1),mapI; // from ReesAlgebra: the map Rees>Kxt 364 372 365 list images=psi(preimages); 366 373 list images=psi(preimages); 374 367 375 if (dblvl>1) 368 376 { … … 395 403 static 396 404 proc ClosurePower(list images, list #) 397 "USAGE: ClosurePower (L [,#]);405 "USAGE: ClosurePower (L [,#]); 398 406  L a list containing generators of the closure of R[It] in k[x,t] 399 407 (the first size(L)1 elements are the numerators, the last one 400 408 is the denominator) 401  if # is given: #[1] is an integer, compute generators for the 409  if # is given: #[1] is an integer, compute generators for the 402 410 closure of I, I^2, ..., I^#[1] 403 411 COMPUTE: the integral closure of I, ... I^#[1]. If # is not given, compute … … 405 413 in the closure of R[It] (so this is the last one that is not just 406 414 the sum/product of the above ones). 407 RETURN: a list containing generators of the closure of the desired powers 408 of I as elements of k[x,t]. 415 RETURN: a list containing generators of the closure of the desired powers 416 of I as elements of k[x,t]. 409 417 " 410 418 { 411 int dblvl=printlevelvoice+2; // toggles how much data is printed 412 // during the procedure 419 int dblvl=printlevelvoice+2; // toggles how much data is printed 420 // during the procedure 413 421 414 422 int j,k,d,computepow; // some counters … … 431 439 432 440 intmat m[nvars(basering)1][1]; // an intvec used for jet and maxdeg1 433 intvec tw=m,1; // such that t has weight 1 and all 441 intvec tw=m,1; // such that t has weight 1 and all 434 442 // other variables have weight 0 435 443 … … 453 461 } 454 462 } 455 } 463 } 456 464 457 465 if (dblvl>0) … … 485 493 { 486 494 image=images[j]jet(images[j],k1,tw); 487 if (image<>0) 488 { 495 if (image<>0) 496 { 489 497 image=subst(image/t^k,t,0); 490 498 if (image<>0) … … 507 515 508 516 for (k=2;k<=pow;k++) 509 { 517 { 510 518 for (j=1;j<=(k div 2);j++) 511 { 519 { 512 520 result[k]=result[k]+result[j]*result[kj]; 513 521 } 514 522 } 515 523 516 524 return(result); 517 525 } … … 520 528 521 529 proc normalI(ideal I, list #) 522 "USAGE: normalI (I [,p[,r]]); I an ideal, p and r optional integers523 COMPUTE: the integral closure of I, ..., I^p. If p is not given, or p==0, 524 compute the closure of all powers up to the maximum degree in t 525 occurring in the closure of R[It] (so this is the last one that 530 "USAGE: normalI (I [,p[,r]]); I an ideal, p and r optional integers 531 COMPUTE: the integral closure of I, ..., I^p. If p is not given, or p==0, 532 compute the closure of all powers up to the maximum degree in t 533 occurring in the closure of R[It] (so this is the last one that 526 534 is not just the sum/product of the above ones). 527 If r is given and <>1, the check whether the input ideal is 535 If r is given and <>1, the check whether the input ideal is 528 536 already a radical ideal is omitted. 529 537 RETURN: a list containing the closure of the desired powers of I as ideals 530 of the basering. 538 of the basering. 539 DISPLAY: The procedure displays more comments for higher printlevel 540 EXAMPLE: example normalI; shows an example 531 541 " 532 542 { 533 int dblvl=printlevelvoice+2; // toggles how much data is printed 543 int dblvl=printlevelvoice+2; // toggles how much data is printed 534 544 // during the procedure 535 545 … … 544 554 { 545 555 "// Trivial case: I is a principal ideal"; 546 } 556 } 547 557 list result=I; 548 558 if (size(#)>0) … … 552 562 result=insert(result,I*result[k],k); 553 563 } 554 } 564 } 555 565 return(result); 556 566 } … … 584 594 result=insert(result,I*result[k],k); 585 595 } 586 } 596 } 587 597 return(result); 588 598 } … … 595 605 "// We start with the Rees Algebra of I:"; 596 606 } 597 607 598 608 list Rees = ReesAlgebra(I); 599 609 def R(1)=Rees[1]; 600 610 def Kxt=Rees[2]; 601 611 setring R(1); 602 612 603 613 if (dblvl>0) 604 614 { … … 608 618 "// Now ClosureRees computes generators for the integral closure"; 609 619 "// of R[It] step by step"; 610 } 620 } 611 621 612 622 // ClosureRees computes fractions in R[x,t] representing the generators … … 628 638 "//I is integrally closed!"; 629 639 } 630 640 631 641 setring BAS; 632 642 list result=I; … … 637 647 result=insert(result,I*result[k],k); 638 648 } 639 } 649 } 640 650 return(result); 641 651 } 642 652 643 653 // construct the fractions corresponding to the generators of the 644 // closure of I and its powers, depending on # (in fact, they will 654 // closure of I and its powers, depending on # (in fact, they will 645 655 // not be real fractions, of course). This is done in ClosurePower. 646 656 … … 651 661 setring BAS; 652 662 list result=fetch(Kxt,result); 653 return(result); 663 return(result); 654 664 } 655 665 example 656 666 { 667 "EXAMPLE:"; echo=2; 657 668 ring R=0,(x,y),dp; 658 669 ideal I = x2,xy4,y5;
Note: See TracChangeset
for help on using the changeset viewer.