Changeset 676724 in git
 Timestamp:
 Mar 19, 2001, 11:57:16 PM (22 years ago)
 Branches:
 (u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
 Children:
 8c4269a2193d8ebf4d512ac0304fe2a3644f8533
 Parents:
 4e18c51925ab32021341e7172545db0b399b0eab
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

Singular/LIB/normal.lib
r4e18c5 r676724 1 1 /////////////////////////////////////////////////////////////////////////////// 2 version="$Id: normal.lib,v 1.3 4 20010222 09:25:01 lossenExp $";2 version="$Id: normal.lib,v 1.35 20010319 22:57:16 greuel Exp $"; 3 3 category="Commutative Algebra"; 4 4 info=" … … 71 71 72 72 proc HomJJ (list Li) 73 "USAGE: HomJJ (Li); Li = list: ideal SBid, ideal id, ideal J, poly p73 "USAGE: HomJJ (Li); Li list: ideal SBid, ideal id, ideal J, poly p, int count 74 74 ASSUME: R = P/id, P = basering, a polynomial ring, id an ideal of P, 75 75 @* SBid = standard basis of id, 76 76 @* J = ideal of P containing the polynomial p, 77 77 @* p = nonzero divisor of R 78 @* count controls printlevel during recursive call 78 79 COMPUTE: Endomorphism ring End_R(J)=Hom_R(J,J) with its ring structure as 79 80 affine ring, together with the canonical map R > Hom_R(J,J), … … 92 93 // initialisation  93 94 94 int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y ;95 int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y,count; 95 96 intvec rw,rw1; 96 97 list L; 97 y = printlevelvoice+2; // y=printlevel (default: y=0) 98 if(size(Li)>=5) 99 { 100 count = Li[5]; 101 } 102 y = printlevelvoice+count; 98 103 def P = basering; 99 104 ideal SBid, id, J = Li[1], Li[2], Li[3]; … … 147 152 { "// the module p*Hom(J,J) = p*J:J, p a nonzerodivisor"; 148 153 "// p"; p; 149 "// f=p*J:J";f; 154 "// f=p*J:J"; 155 if( y>=2 ) { f; } 150 156 } 151 157 f2 = std(p); … … 187 193 attrib(endid,"isCompleteIntersection",0); 188 194 attrib(endid,"isRad",0); 189 // export endid;190 // export endphi;191 // L = newR1;192 195 L=lastRing; 193 196 L = insert(L,1,1); 194 dbprint(y,"// case R = Hom(J,J)");195 197 if(y>=1) 196 198 { 197 "// R=Hom(J,J)";199 "// case R = Hom(J,J), we are ready with this component"; 198 200 " "; 199 lastRing; 201 if( y>=2 ) 202 { 203 lastRing; 200 204 " "; 201 205 "// the new ideal"; 202 endid;206 if( y>=2 ) { endid; } 203 207 " "; 204 208 "// the old ring"; … … 218 222 pause(); 219 223 newline; 224 } 220 225 } 221 226 setring P; … … 225 230 { 226 231 "// R is not equal to Hom(J,J), we have to try again"; 227 pause(); 228 newline; 232 if( y>=2 ) 233 { pause(); 234 newline; 235 } 229 236 } 230 237 // Hom(J,J) != R: create new ring and map from old ring  … … 279 286 "// the linear relations"; 280 287 " "; 281 Lin; 282 " "; 288 if( y>=2 ) 289 { Lin; 290 pause(); 291 ""; 292 } 283 293 } 284 294 for (ii=2; ii<=q; ii++ ) … … 293 303 { 294 304 "// the quadratic relations"; 295 " "; 296 interred(Quad); 297 pause(); 298 newline; 305 if( y>=2 ) 306 { 307 " "; 308 interred(Quad); 309 pause(); 310 newline; 311 } 299 312 } 300 313 Q = Lin+Quad; … … 329 342 { 330 343 "// the new ring after reduction of the number of variables"; 331 " "; 344 show(lastRing); 345 pause(); " 346 "; 347 if(y >=2) 348 { 332 349 lastRing; 333 350 " "; … … 352 369 pause(); 353 370 newline; 371 } 354 372 } 355 373 L = lastRing; … … 391 409 @end format 392 410 NOTE: to use the ith ring type: def R=nor[i]; setring R;. 393 @* Increasing printlevel displays more comments (default: printlevel=0) 394 @* Not implemented for local or mixed orderings. 411 @* Not implemented for local or mixed orderings and quotient rings. 395 412 @* If the input ideal i is weighted homogeneous a weighted ordering may 396 413 be used (qhweight(i); computes weights). 414 @* printlevel = 1: count normalization loops (default: printlevel=0) 415 @* printlevel > 1: protocoll of normalization steps 416 @* printlevel > 2: protocoll of all normalization steps, pauses 417 @* printlevel > 3: display some (>4 all) intermediate results, pauses 397 418 EXAMPLE: example normal; shows an example 398 419 " … … 452 473 if(y>=1) 453 474 { 454 "// we have ",size(prim),"equidimensional components"; 475 ""; 476 "// we have ",size(prim),"equidimensional component(s)"; 455 477 } 456 478 } … … 465 487 else 466 488 { 467 prim=minAss Primes(id);489 prim=minAssGTZ(id); 468 490 } 469 491 } 470 492 else 471 493 { 472 prim=minAss Primes(id);494 prim=minAssGTZ(id); 473 495 } 474 496 if(y>=1) 475 497 { 476 "// we have ",size(prim),"irreducible components"; 498 ""; 499 "// we have ",size(prim),"irreducible component(s)"; 477 500 } 478 501 } … … 481 504 if(y>=1) 482 505 { 483 "// we are in loop ",i; 506 ""; 507 "// BEGIN with equidimensional/irreducible component",i; 484 508 } 485 509 attrib(prim[i],"isCohenMacaulay",0); … … 508 532 {attrib(prim[i],"isIsolatedSingularity",1); } 509 533 } 510 keepresult=normalizationPrimes(prim[i],maxideal(1) );534 keepresult=normalizationPrimes(prim[i],maxideal(1),0); 511 535 for(j=1;j<=size(keepresult);j++) 512 536 { … … 518 542 // 'normal' created a list of "+sr+" ring(s). 519 543 // To see the rings, type (if the name of your list is nor): 520 show( 544 show(nor); 521 545 // To access the 1st ring and map (similar for the others), type: 522 546 def R = nor[1]; setring R; norid; normap; … … 540 564 541 565 /////////////////////////////////////////////////////////////////////////////// 542 static proc normalizationPrimes(ideal i,ideal ihp, list #) 543 "USAGE: normalizationPrimes(i,ihp[,si]); i prime ideal, ihp map 544 (partial normalization), si SB of singular locus 566 static proc normalizationPrimes(ideal i,ideal ihp, int count, list #) 567 "USAGE: normalizationPrimes(i,ihp[,si,countt]); i prime ideal, ihp map 568 (partial normalization), si ideal of singular locus, 569 count = integer to count the number of normalization loops 545 570 RETURN: a list of one ring L=R, in R are two ideals 546 S,M such that R/M is the normalization 571 S,M such that R/M is the normalization of original basering 547 572 S is a standardbasis of M 548 573 NOTE: to use the ring: def r=L[1];setring r; 549 printlevel >= voice+1: display comments (default: printlevel=0) 574 printlevel = 1: count normalization loops (default: printlevel=0) 575 printlevel > 1: protocoll of normalization steps 576 printlevel > 2: protocoll of all normalization steps, pauses 577 printlevel > 3: display some (>4 all) intermediate results, pauses 550 578 EXAMPLE: example normalizationPrimes; shows an example 551 579 " 552 580 { 553 int y = printlevelvoice+2; // y=printlevel (default: y=0) 554 555 if(y>=1) 556 { 557 ""; 558 "// START a normalization loop with the ideal"; ""; 581 count = count+1; 582 int y = printlevelvoice+count+1; // y=printlevel (default: y=0) 583 if(y>=0) 584 { 585 "// START normalization LOOP ",count; 586 } 587 if( y>=3) 588 { 589 "// with ideal"; ""; 559 590 i; ""; 560 591 basering; ""; … … 562 593 newline; 563 594 } 595 564 596 565 597 def BAS=basering; … … 588 620 if(y>=1) 589 621 { 590 "// SBcomputation of the input ideal"; 591 } 592 593 list SM=mstd(i); //here the work starts 594 int dimSM = dim(SM[1]); //dimension of variety to normalize 622 "// SBcomputation of ideal of size",size(i),"in ring with",nvars(basering),"variables"; 623 } 624 //  SBcomputation of the input ideal  625 list SM=mstd(i); //here the work starts, SM[1] a SB of i 626 //SM[2] a smaller set of generators of i 627 int dimSM = dim(SM[1]); //dimension of i, V(i)=variety to normalize 595 628 // Case: Get an ideal containing a unit 596 629 if( dimSM == 1) … … 620 653 } 621 654 622 if(size(#)>0) 655 if(size(#)>0) //ideal of sing locus is given in #[1] 623 656 { 624 657 list JM=mstd(#[1]); … … 629 662 } 630 663 664 //  transfer attributes from ideal i to SM[2], SM = mstd(i)  631 665 if(attrib(i,"isPrim")==1) 632 666 { … … 678 712 } 679 713 680 //the smooth case 714 //************* case 0: check and prepare special cases **************** 715 //no computation for the normalization in case 0 716 717 // the smooth case  681 718 if(size(#)>0) 682 719 { … … 702 739 } 703 740 } 704 705 //the zerodimensional case 741 // recall: SM = mstd(i), i = ideal to start with in normaliztion loop 742 // JM = mstd(#[1]), #[1]= ideal of singular locus of i 743 // #[1] is given after the first normalization loop 744 745 // the homogeneous zerodimensional case  706 746 if((dim(SM[1])==0)&&(homog(SM[2])==1)) 707 747 { … … 725 765 } 726 766 727 //the onedimensional case 728 //in this case it is a line because 729 //it is irreducible and homogeneous 767 // the homogeneous onedimensional case  768 //in this case i defines a line because it is irreducible and homogeneous 730 769 if((dim(SM[1])==1)&&(attrib(SM[2],"isPrim")==1) 731 770 &&(homog(SM[2])==1)) … … 749 788 return(result); 750 789 } 751 752 //the higher dimensional case 790 // the higher dimensional case  753 791 //we test first of all CohenMacaulay and 754 792 //complete intersection … … 766 804 767 805 //compute the singular locus+lower dimensional components 768 if(((attrib(SM[2],"isIsolatedSingularity")==0)(homog(SM[2])==0)) 769 &&(size(#)==0)) 770 { 771 /* 772 write (":a normalfehler" , 773 "basering:",string(basering),"nvars:", nvars(basering), 774 "dim(SM[1]):",dim(SM[1]),"ncols(jacob(SM[2]))",ncols(jacob(SM[2])), 775 "SM:", SM); 776 777 pause(); 778 */ 806 807 // case: not(isolated singularity and homogeneous)  808 if((attrib(SM[2],"isIsolatedSingularity")==0) && (size(#)==0)) 809 { 810 // computation of ideal of singular locus  779 811 J=minor(jacob(SM[2]),nvars(basering)dim(SM[1])); 780 812 //ti=timer; 781 813 if(y >=1 ) 782 814 { 783 "// SB of singular locus will be computed"; 784 } 785 ideal sin=J+SM[2]; 786 787 //kills the embeded components 788 815 "// SB of singular locus will be computed "; 816 if(y >=2 ) 817 { 818 "//in ring:"; 819 show(basering); 820 } 821 } 822 823 J = simplify(J,16); //this makes ist for huge J much faster 824 ideal sin=J,SM[2]; 789 825 list JM=mstd(sin); 790 //JM[1] SB os singular locus, JM[2]=minbasis of singular locus 791 //SM[1] SB of irreducible component, SM[2] minbasis 826 827 //JM[1] SB of singular locus, JM[2] minbasis of singular locus 828 //SM[1] SB of ideal in normalisation loop, SM[2] minbasis 829 792 830 if(y>=1) 793 831 { … … 817 855 return(result); 818 856 } 819 if(dim(JM[1])==0 )857 if(dim(JM[1])==0 && (homog(SM[2])==1)) 820 858 { 821 859 attrib(SM[2],"isIsolatedSingularity",1); … … 826 864 } 827 865 } 828 else 866 867 // case: isolated singularity and homogeneous  868 if(attrib(SM[2],"isIsolatedSingularity")==1) 829 869 { 830 870 if(size(#)==0) 831 871 { 832 list JM=maxideal(1),maxideal(1); 833 872 if(defined(JM)==voice) 873 { JM=maxideal(1),maxideal(1); 874 } 875 else 876 { list JM=maxideal(1),maxideal(1); 877 878 } 834 879 attrib(JM[1],"isSB",1); 835 attrib(SM[2],"isRegInCodim2",1);836 880 } 837 881 } 882 883 // case: Cohen Macaulay and regular in codim 2  884 //in this case we are ready, the ring is normal 838 885 if((attrib(SM[2],"isRegInCodim2")==1)&&(attrib(SM[2],"isCohenMacaulay")==1)) 839 886 { … … 856 903 return(result); 857 904 } 858 //if it is an isolated singularity things are easier 905 906 //************* case 1: isolated singularity and homogeneous **************** 907 908 // recall: SM = mstd(i), i = ideal to start with in normaliztion loop 909 // JM = mstd(#[1]), #[1]= ideal of singular locus of i 910 // #[1] is given after the first normalization loop 911 //if SM is an isolated singularity and homogeneous, we know that this 912 //persists in the following normalization loops and things are easier 913 //since the radical of the singular locus is the maximal ideal 859 914 //JM ideal of singular locus, SM ideal of variety 860 if((dim(JM[1])==0)&&(homog(SM[2])==1)) //isolated sing. case 861 { 862 attrib(SM[2],"isIsolatedSingularity",1); 915 916 if(attrib(SM[2],"isIsolatedSingularity")==1) 917 { 918 if(y>=1) 919 { 920 "// CASE 1: unique isolated singularity at 0"; 921 "// radial of singular locus is the maximal ideal"; 922 } 863 923 ideal SL=simplify(reduce(maxideal(1),SM[1]),2); 864 //vars not contained in ideal924 //SL = vars not contained in ideal 865 925 ideal Ann=quotient(SM[2],SL[1]); 866 ideal qAnn=simplify(reduce(Ann,SM[1]),2); 867 926 ideal qAnn=simplify(reduce(Ann,SM[1]),2); 868 927 //qAnn=0 ==> the first var(=SL[1]) not contained in SM is a nzd of R/SM 928 // case: a nonzerodivisor was found  869 929 if(size(qAnn)==0) 870 930 { … … 872 932 { 873 933 ""; 934 "// a nonzerodivisor was found"; 874 935 "// the ideal rad(J):"; 875 936 ""; 876 937 maxideal(1); 877 938 newline; 939 "// TEST for normality: R=Hom(J,J)?"; 940 ""; 878 941 } 879 //again test for normality880 // Hom(I,R)=R942 //test for normality: 943 //?spaeter: test for normality, Hom(I,R)==R? 881 944 list RR; 882 RR=SM[1],SM[2],maxideal(1),SL[1]; 883 ti=timer; 884 RR=HomJJ(RR,y); 885 if(RR[2]==0) 945 RR=SM[1],SM[2],maxideal(1),SL[1],count; 946 // ti=timer; 947 RR=HomJJ(RR); 948 // timerti; 949 if(RR[2]==0) 950 //the ring is not normal, start a new normalization loop 886 951 { 887 952 def newR=RR[1]; 888 953 setring newR; 889 954 map psi=BAS,endphi; 890 // ti=timer; 891 list tluser=normalizationPrimes(endid,psi(ihp)); 892 893 // timerti; 955 // ti=timer; 956 list tluser=normalizationPrimes(endid,psi(ihp),count); 957 // timerti; 894 958 setring BAS; 895 959 return(tluser); 896 960 } 961 //the ring is normal, prepare output and go home 897 962 MB=SM[2]; 898 963 execute("ring newR7="+charstr(basering)+",("+varstr(basering)+"),(" … … 903 968 export normap; 904 969 result=newR7; 905 // the following 2 lines don't work : nor is not defined906 //def R = nor[1]; setring R; //make the 1st ring the basering907 //norid; normap; //data of the normalization)908 970 setring BAS; 909 971 return(result); 910 972 911 973 } 912 //Now the case where qAnn!=0, i.e.SL[1] is a zero divisor of R/SM 974 // case: a zerodivisor was found  975 //Now the case where qAnn!=0, i.e.SL[1] is a zerodivisor of R/SM 913 976 //and we have found a splitting: id and id1 914 977 //id=qAnn+SM[2] defines components of R/SM in the complement of V(SL[1]) … … 917 980 else 918 981 { 982 if(y>=0) 983 { 984 "// a zerodivisor was found, we have SPLITTING of ideals"; 985 if(y >=2 ) 986 { 987 "// in ring:"; 988 show(basering); 989 } 990 ""; 991 } 992 919 993 ideal id=qAnn+SM[2]; 920 994 … … 926 1000 attrib(id,"isEquidimensional",0); 927 1001 928 keepresult1=normalizationPrimes(id,ihp); 1002 if(y>=0) 1003 { 1004 "// start a normalization loop with 1st split ideal (size",size(id),"in",nvars(basering),"vars)"; 1005 } 1006 keepresult1=normalizationPrimes(id,ihp,count); 929 1007 ideal id1=quotient(SM[2],Ann)+SM[2]; 930 1008 // evtl. qAnn statt Ann nehmen … … 938 1016 attrib(id1,"isEquidimensional",0); 939 1017 940 keepresult2=normalizationPrimes(id1,ihp); 1018 if(y>=0) 1019 { 1020 "// start a normalization loop with 2nd split ideal (size",size(id),"in",nvars(basering),"vars)"; 1021 } 1022 keepresult2=normalizationPrimes(id1,ihp,count); 941 1023 942 1024 for(lauf=1;lauf<=size(keepresult2);lauf++) … … 948 1030 } 949 1031 950 //test for nonnormality 951 //Hom(I,I)<>R 952 //we can use Hom(I,I) to continue 1032 //********** case 2: no unique isolated singularity at 0 ************* 1033 1034 //in this case the radical must be computed 1035 // recall: SM = mstd(i), i = ideal to start with in normaliztion loop 1036 // JM = mstd(#[1]), #[1]= ideal of singular locus of i 1037 // #[1] is given after the first normalization loop 1038 //test for normality: Hom(J,J)=R 1039 //test for nonnormality: Hom(J,J)!=R, we can use Hom(J,J) to continue 1040 1041 if(y>=1) 1042 { 1043 "// CASE 2: no unique isolated singularity"; 1044 "// radical has to be computed"; 1045 } 953 1046 954 1047 ideal SL=simplify(reduce(JM[2],SM[1]),2); 1048 //SL = elements of ideal of singular locus not contained in ideal i 955 1049 ideal Ann=quotient(SM[2],SL[1]); 956 1050 ideal qAnn=simplify(reduce(Ann,SM[1]),2); 957 1051 //qAnn=0 ==> SL[1] is a nonzerodivisor of R/SM 1052 1053 // case: a nonzerodivisor was found  958 1054 if(size(qAnn)==0) 959 1055 { 960 1056 list RR; 961 1057 list RS; 962 1058 //now we have to compute the radical 963 1059 if(y>=1) 964 1060 { 965 "// radical computation of singular locus"; 966 } 967 968 //J=radical(SM[2]+ideal(SL[1])); //JM[2] contains SM[2]+ideal(SL[1]) 969 J=radical(JM[2]); //the singular locus 1061 ""; 1062 "// a nonzerodivisor was found"; 1063 "// radical computation of ideal of singular locus"; 1064 } 1065 1066 // computation of the radical J  1067 //We have at least two possibilities: 1068 //J=radical(JM[2]), the radical of the full singular locus, or 1069 //J=radical(SM[2]+ideal(SL[1])), JM[2] contains SM[2]+ideal(SL[1]) 1070 //the first is usually better! 1071 970 1072 if(y>=1) 971 1073 { 972 "// radical is equal to:";""; 973 J; 1074 "// compute radical J of ideal of singular locus";""; 1075 } 1076 1077 J=radical(JM[2]); 1078 // alternativ: J=radical(SM[2]+ideal(SL[1])); 1079 1080 if(y>=2) 1081 { 1082 "// the radical is equal to:"; 1083 J; 1084 newline; 1085 } 1086 if(y>=1) 1087 { 1088 "// TEST for normality: R=Hom(J,J)?"; 974 1089 ""; 975 1090 } 976 1091 977 JM=J,J; 978 1092 JM=J,J; //J = new ideal for singular locus 979 1093 //evtl. fuer SL[1] anderen Nichtnullteiler aus J waehlen 980 RR=SM[1],SM[2],JM[2],SL[1]; 981 982 // evtl eine geeignete Potenz von JM? 983 if(y>=1) 984 { 985 "// compute Hom(rad(J),rad(J))"; 986 } 987 988 RS=HomJJ(RR,y); 989 1094 1095 //test for normality: 1096 RR=SM[1],SM[2],JM[2],SL[1],count; 1097 RS=HomJJ(RR); 1098 1099 // the ring is normal, prepare output and go home 990 1100 if(RS[2]==1) 991 1101 { … … 1001 1111 return(lastR); 1002 1112 } 1113 1114 // the ring is not normal, start a new normalization loop 1003 1115 int n=nvars(basering); 1004 1116 ideal MJ=JM[2]; … … 1009 1121 map psi=BAS,endphi; 1010 1122 list tluser= 1011 normalizationPrimes(endid,psi(ihp),simplify(psi(MJ)+endid,4));1123 normalizationPrimes(endid,psi(ihp),count,simplify(psi(MJ)+endid,4)); 1012 1124 setring BAS; 1013 1125 return(tluser); 1014 1126 } 1015 // A component with singular locus the whole component found 1127 // case: a zerodivisor was found  1128 //Now the case where qAnn!=0, i.e.SL[1] is a zerodivisor of R/SM 1129 //and we have found a splitting: id and id1 1130 //id=qAnn+SM[2] defines components of R/SM in the complement of V(SL[1]) 1131 //id1 defines components of R/SM in the complement of V(id) 1132 //?????instead of id1 we can take SL[1]+Ann+SM[2]??????????? 1133 1134 // A component with singular locus the whole component found: 1016 1135 if( Ann == 1) 1017 1136 { … … 1035 1154 return(result); 1036 1155 } 1156 // The general case with splitting of ring, i.e. qAnn!=0 1037 1157 else 1038 1158 { … … 1041 1161 execute("ring newR1="+charstr(basering)+",("+varstr(basering)+"),(" 1042 1162 +ordstr(basering)+");"); 1043 if(y>=1) 1044 { 1045 "// zerodivisor found"; 1163 if(y>=0) 1164 { 1165 "// a zerodivisor was found, we have SPLITTING of ideals"; 1166 ""; 1046 1167 } 1047 1168 ideal vid=fetch(BAS,new1); … … 1061 1182 attrib(vid,"isCompleteIntersection",0); 1062 1183 1063 keepresult1=normalizationPrimes(vid,ihp); 1184 if(y>=0) 1185 { 1186 "// start a normalization loop with 1st split ideal (size",size(vid),"in",nvars(basering),"vars)"; 1187 } 1188 1189 keepresult1=normalizationPrimes(vid,ihp,count); 1064 1190 1065 1191 setring BAS; … … 1085 1211 attrib(vid,"isCompleteIntersection",0); 1086 1212 1087 keepresult2=normalizationPrimes(vid,ihp); 1213 if(y>=0) 1214 { 1215 "// start a normalization loop with 2nd split ideal (size",size(vid),"in",nvars(basering),"vars)"; 1216 } 1217 1218 keepresult2=normalizationPrimes(vid,ihp,count); 1088 1219 1089 1220 setring BAS; … … 1109 1240 b6c+bc6+a2b4e3ab2c2de+c4d2ea3cde2abd3e2+bce5; 1110 1241 1111 list pr=normalizationPrimes(i );1242 list pr=normalizationPrimes(i,maxideal(1),1); 1112 1243 def r1=pr[1]; 1113 1244 setring r1; … … 1216 1347 ///////////////////////////////////////////////////////////////////////////// 1217 1348 /* 1349 Aenderungen: 1350 1. normal kommentiert, bei Berechnung de singulaeren Ortes ein simplify(J,16) 1351 eingefuehrt, um bei riesigen Minorenzahlen, das Ideal zu verkleinern (bis 1352 Faktor 10 Beschleunigung). 1353 Protokoll mit printlevel so gesteuert, dass es bei rekursivem Aufruf korrekt 1354 arbeitet. 1355 list nor = normal(i); //mit equidim Zerlegung 1356 list nor = normal(i,1); //mit prim Zerlegung 1357 Zeiten au sony_pumuckel (P2, 500) 1218 1358 Examples: 1219 1359 LIB"normal.lib"; 1220 //Huneke 1360 //1. Huneke, 1 Komponente 1361 //prim: 2 sec equidim:1sec 1221 1362 ring qr=31991,(a,b,c,d,e),dp; 1222 1363 ideal i= … … 1231 1372 1232 1373 1233 // Vasconcelos (dauert laenger: 60 sec)1374 //2. Vasconcelos (dauert laenger: 83 sec auf sony_pumuckel) 1234 1375 ring r=32003,(x,y,z,w,t),dp; 1235 1376 ideal i= … … 1238 1379 xw3+z3t+ywt2, 1239 1380 y2w4xy2z2tw3t3; 1381 1382 //2a. Vasconcelos verkleinert 1383 //prim:2Komp, 2 Ringe, 16 sec (manchmal lange, haengt am Faktorisierer) 1384 //equidim: 1 Komp, 7 loops, 2 ringe, 12sec 1385 ring r=32003,(x,y,z,w,t),dp; 1386 ideal i= 1387 x+zw, 1388 y3+xwt, 1389 xw3+z3t+ywt2; 1390 1391 //3. GM1 1392 // irreducible, 13 normalization loops, 1 Ring 1393 //2sec mit prim, 1 sec mit equidim 1394 ring r=32003,(x,y,z,u),dp; 1395 ideal i = x2+y3,z2+u3,y2+z3; 1396 1397 //3a. GM1 1398 ring r=32003,(x,y),dp; 1399 ideal i = intersect(y3+x2,y2+x3); // beide 0 sec 1400 ideal i = intersect(y3+x2,y2+x3,y2+x2+x3); 1401 //prim 0sec, 1402 //equidim sehr lange (Relationen in HomJJ zu gross) 1403 1404 //4. GM2 1405 //i nicht reduziert, equidim bricht ab (0 sec) 1406 //prim: 11 irred comp, 11 loops, (1sec) 1407 ring r=32003,(x,y,z,u),dp; 1408 ideal i = x2+y3,z2+u3,y2+z3,x2+z3; 1409 1410 //5. GM3, radical von GM2 1411 //prim: 11 irred comp, 11 loops, 11 Ringe, (1sec) 1412 //equidim: 1 equidim comp, 1 loop, 1 Ring, (0sec) 1413 ring r=32003,(x,y,z,u),dp; 1414 ideal i =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3y; 1415 1416 //GM4 1417 //equidim: 2 equidim comp, 3 Ringe, (0sec); 1418 //prim: 3 Komp, (0sec) 1419 ring r=32003,(x,y,z,u),dp; 1420 ideal i1 = x2+y3,u,z; 1421 ideal i2 = u2+z3,x,y; 1422 ideal i3 = x2+y2+z2+u4; 1423 ideal i = intersect(i1,i2,i3); 1424 1425 //GM4a Hier dauert prim laenger! (## facstd) 1426 //equidim: 3 equidim Komp, 4 Ringe(0sec) 1427 //prim 13 Komp (63 sec), wegen facstd 1428 //##ev minAssGTZ(i,1) verwenden (ohne facstd, ist noch fehlerhaft) 1429 ring r=32003,(x,y,z,u),dp; 1430 ideal i1 = x2+y3,u,z; 1431 ideal i2 = u2+z3,x,y; 1432 ideal i3 = x2+y2+z2+u4; 1433 ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3y; 1434 ideal i = intersect(i1,i2,i3,i4); 1435 1436 //GM5 1437 //equidim: 4 Komp,0sec, prim 13 Komp, 1sec 1438 ring r=32003,(x,y,z,u,v),dp; 1439 ideal i1 = x2+y3,v; //2dim 1440 ideal i2 = u2+z3,x,y; //3dim 1441 ideal i3 = x2+y2+z2+u4; //4dim 1442 ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3y; //1dim 1443 ideal i = intersect(i1,i2,i3,i4); 1444 1445 //cyclic 5 1446 //equidim: 1 Komp 0sec, prim: 20 Komp, 3 sec 1447 ring r=32003,(x,y,z,u,v),dp; 1448 ideal i = 1449 x+y+z+u+v, 1450 xy+yz+zu+xv+uv, 1451 xyz+yzu+xyv+xuv+zuv, 1452 xyzu+xyzv+xyuv+xzuv+yzuv, 1453 xyzuv1; 1454 1455 // cyclic 5 hat Normalisierung (1 embim weniger) 1456 ///equidim: 1 Komp 0sec, prim: 20 Komp, 2 sec 1457 ring r=32003,(x,y,z,u),dp; 1458 ideal i = 1459 x2+xzyz+2xu+yu+u2, 1460 xy2xyz+y2zy2u+xzu+yzu+z2uxu22yu2+zu2u3, 1461 xyz2+xyzu+y2zuxz2u+yz2uz3uxyu2xzu22z2u2+xu3+yu3zu3+u4, 1462 2xyzu2+y2zu2+2yz2u2xyu32xzu3yzu3z2u3+xu4+yu42zu4+u51; 1463 1464 //cyclic(6) 1465 //equidim: 1Komp in 5 vars 1sec 1466 //prim: 90 (!) Ringe, 12 sec 1240 1467 1241 1468 //Theo1 … … 1284 1511 ad; 1285 1512 1286 // Beispiel, wo vorher Primaerzerlegungschneller (2 sec,sonst 860 sec)1513 //Sturmfels, wo vorher Prim schneller (2 sec,sonst 860 sec) 1287 1514 //ist CM 1288 //Sturmfels 1515 //prim: 15 loops, 15 Komp, 1 sec, 1516 //equidim:15 Ringe, 93 sec mit simplify(J,16), 1517 //ohne simlify(J,16) 860sec?, 1518 //andere simplify sind z.T. viel langsamer 1289 1519 ring r=32003,(b,s,t,u,v,w,x,y,z),dp; 1290 1520 ideal i= … … 1317 1547 tuybvz; 1318 1548 1319 //dauert laenger ohne Primaerzerlegung vorher (1 sec gegen1320 1549 //Horrocks: 1321 ring r=32003,(a,b,c,d,e,f),dp; 1550 //CHAR 32003:mit prim 1 sec, equidim: 115 sec, beide 6 Ringe 1551 // Singulaere Ort hat zu Beginn > 106 000 Erzeuger!! 1552 //char 31991: prim 1sec, 8 Ringe, equidim: 25 Ringe(!), 162 sec, 1553 // nicht reduziert! 1554 // Singulaere Ort hat zu Beginn > 28 000 Erzeuger!! 1555 // i=radical(i) > 8 Ringe, 1sec (radical <1 sec) 1556 //Horrocks: 1557 ring r=31991,(a,b,c,d,e,f),dp; 1322 1558 ideal i= 1323 1559 adef16000be2f+16001cef2, … … 1356 1592 1357 1593 1358 ring r=32003,(b,s,t,u,v,w,x,y,z),dp; 1359 1594 ring r=32003,(b,s,t,u,v,w,x,y,z),dp; //3sec 1360 1595 ideal k= 1361 1596 wyvz, … … 1367 1602 ideal i=mstd(intersect(j,k))[2]; 1368 1603 1369 //22 1604 //22, 1605 // neu, prim: 3 sec, equidim 1 sec, je 4 Ringe 1370 1606 ring r=32003,(b,s,t,u,v,w,x,y,z),dp; 1371 1607 ideal i= … … 1377 1613 1378 1614 1379 //riemenschneider 1380 //33 1381 //normal+primary 3 1382 //primary 9 1383 //radical 1 1384 //minAssPrimes 2 1615 //riemenschneider, 5 Komponenten 1616 //33(alte Zeiten), normal+primary 3, primary 9, radical 1, minAssGTZ; 2 1617 //neu: prim 0sec, equi 1 sec, je 5 Ringe 1385 1618 ring r=32000,(p,q,s,t,u,v,w,x,y,z),wp(1,1,1,1,1,1,2,1,1,1); 1386 1619 ideal i= … … 1398 1631 1399 1632 ring r=0,(u,v,w,x,y,z),wp(1,1,1,3,2,1); 1400 ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3x2; 1633 ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3x2; //0sec 1401 1634 */ 1402 1635
Note: See TracChangeset
for help on using the changeset viewer.