Changeset 2cd0ca in git
- Timestamp:
- Feb 1, 2007, 7:39:17 PM (17 years ago)
- Branches:
- (u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
- Children:
- 07b1cfb3569d892601e457e29b9082efcebeb8fd
- Parents:
- ec69aa9f2368fd5481b412fc4b4a37844f40d997
- File:
-
- 1 edited
-
Singular/LIB/reszeta.lib (modified) (25 diffs)
Legend:
- Unmodified
- Added
- Removed
-
Singular/LIB/reszeta.lib
rec69aa r2cd0ca 1 1 ////////////////////////////////////////////////////////////////////////////// 2 version="$Id: reszeta.lib,v 1. 9 2006-07-25 17:54:29 Singular Exp $";2 version="$Id: reszeta.lib,v 1.10 2007-02-01 18:39:17 krueger Exp $"; 3 3 category="Commutative Algebra"; 4 4 info=" … … 1758 1758 RETURN: list l 1759 1759 if a is not present: 1760 l[1]: string specifying the Denef-Loeser zeta function 1760 l[1]: string specifying the Denef-Loeser zeta function 1761 1761 l[2]: string specifying characteristic polynomial of monodromy, 1762 1762 if "A" was specified … … 3296 3296 iden=tmpiden; // store the modified divisor list 3297 3297 kill tmpiden; // and clean up temporary objects 3298 iden; 3298 3299 //--------------------------------------------------------------------------- 3299 3300 // Now we have decomposed everything into irreducible components over Q, … … 4062 4063 if k==0, no divisor corresponding to i,j 4063 4064 l[2]: list ll, where each entry of ll is a list of intvecs 4064 entry i,j in list ll[k] implies BO[4][j] of chart i is divisor k 4065 entry i,j in list ll[k] implies BO[4][j] of chart i 4066 is divisor k 4065 4067 l[3]: list L 4066 4068 EXAMPLE: example collectDiv; shows an example … … 4427 4429 //the curve the total transform is n.c. 4428 4430 //this occurs here in r[2][5] 4429 list re=resolve(I, 0);4431 list re=resolve(I,1); 4430 4432 list di=collectDiv(re); 4431 4433 di; … … 4831 4833 if(size(algext)>0) 4832 4834 { 4835 //--- size(algext)>0: case of algebraic extension of base field 4833 4836 if(defined(tstr)){kill tstr;} 4834 4837 string tstr="ring So1=(0,t),("+varstr(L[2][o1])+"),("+ordstr(L[2][o1])+");"; … … 4868 4871 else 4869 4872 { 4873 //--- size(algext)==0: no algebraic extension of base needed 4870 4874 def So1=L[2][o1]; 4871 4875 setring So1; … … 4882 4886 } 4883 4887 // id1=radical(id1); 4884 4885 4888 ideal id2=1; 4886 4889 list idlist; … … 4889 4892 intvec nE; 4890 4893 idlist[1]=list(id1,id2,nE); 4891 } 4894 } 4892 4895 if(defined(tli)){kill tli;} 4893 4896 list tli; … … 4900 4903 for(m=1;m<=size(idlist);m++) 4901 4904 { 4905 //!!! Duplicate Block!!! All changes also needed below!!! 4906 //!!! no subprocedure due to large data overhead!!! 4907 //--- run through all ideals to be fetched 4902 4908 id1=idlist[m][1]; 4903 4909 id2=idlist[m][2]; … … 4905 4911 for(i=branchPos-1;i<=size(BO[4]);i++) 4906 4912 { 4913 //--- run through all relevant exceptional divisors 4907 4914 if(size(reduce(BO[4][i],std(id1+BO[1])))==0) 4908 4915 { 4916 //--- V(id1) is contained in except. div. i in this chart 4909 4917 if(size(reduce(id1,std(BO[4][i])))!=0) 4910 4918 { 4919 //--- V(id1) does not equal except. div. i of this chart 4911 4920 Etemp=BO[4][i]; 4912 4921 if(npars(basering)>0) 4913 4922 { 4923 //--- we are in an algebraic extension of the base field 4914 4924 if(defined(prtemp)){kill prtemp;} 4915 list prtemp=minAssGTZ(BO[4][i]); 4925 list prtemp=minAssGTZ(BO[4][i]); // C-comp. of except. div. 4926 j=1; 4916 4927 if(size(prtemp)>1) 4917 4928 { 4929 //--- more than 1 component 4918 4930 Etemp=ideal(1); 4919 4931 for(j=1;j<=size(prtemp);j++) 4920 4932 { 4933 //--- find correct component 4921 4934 if(size(reduce(prtemp[j],std(id1)))==0) 4922 4935 { … … 4930 4943 } 4931 4944 } 4945 prtemp=delete(prtemp,j); // remove this comp. from list 4946 while(size(prtemp)>1) 4947 { 4948 //--- collect all the others into prtemp[1] 4949 prtemp[1]=intersect(prtemp[1],prtemp[size(prtemp)]); 4950 prtemp=delete(prtemp,size(prtemp)); 4951 } 4932 4952 } 4953 //--- determine tli[1] and tli[2] such that 4954 //--- V(id1) \cap D(id2) = V(tli[1]) \cap D(tli[2]) \cap BO[4][i] 4955 //--- inside V(BO[1]) (and if necessary inside V(BO[1]+BO[2])) 4933 4956 if(inJ) 4934 4957 { 4935 tli=findTrans(id1+BO[2] ,Etemp,notE,BO[2]);4958 tli=findTrans(id1+BO[2]+BO[1],Etemp,notE,BO[2]); 4936 4959 } 4937 4960 else 4938 4961 { 4939 tli=findTrans(id1,Etemp,notE); 4962 tli=findTrans(id1+BO[1],Etemp,notE); 4963 } 4964 if(npars(basering)>0) 4965 { 4966 //--- in algebraic extension: make sure we stay outside the other components 4967 if(size(prtemp)>0) 4968 { 4969 for(j=1;j<=ncols(prtemp[1]);j++) 4970 { 4971 //--- find the (univariate) generator of prtemp[1] which is the remaining 4972 //--- factor from the factorization over the extension field 4973 if(size(reduce(prtemp[1][j],std(id1)))>0) 4974 { 4975 tli[2]=tli[2]*prtemp[1][j]; 4976 } 4977 } 4978 } 4940 4979 } 4941 4980 } 4942 4981 else 4943 4982 { 4983 //--- V(id1) equals except. div. i of this chart 4944 4984 tli[1]=ideal(0); 4945 4985 tli[2]=ideal(1); … … 4965 5005 idlist[m][3]=nE; 4966 5006 } 5007 //!!! End of Duplicate Block !!!! 4967 5008 } 4968 5009 if(o1>1) … … 5016 5057 if(defined(phi)) { kill phi; } 5017 5058 map phi=T,lastMap; 5059 //--- now do the actual blowing down ... 5018 5060 for(m=1;m<=size(idlist);m++) 5019 5061 { 5062 //--- ... for each entry of idlist separately 5020 5063 if(defined(id1)){kill id1;} 5021 5064 if(defined(id2)){kill id2;} 5022 5065 ideal id1=idlist[m][1]+BO[1]; 5023 ideal id2=idlist[m][2] +BO[1];5066 ideal id2=idlist[m][2]; 5024 5067 nE=idlist[m][3]; 5068 if(defined(debug_fetchInTree)>0) 5069 { 5070 "Blowing down entry",m,"of idlist:"; 5071 setring S; 5072 "Abbildung:";phi; 5073 "before preimage"; 5074 id1; 5075 id2; 5076 } 5025 5077 setring T; 5026 5078 ideal id1=preimage(S,phi,id1); 5027 5079 ideal id2=preimage(S,phi,id2); 5080 if(defined(debug_fetchInTree)>0) 5081 { 5082 "after preimage"; 5083 id1; 5084 id2; 5085 } 5086 if(size(id2)==0) 5087 { 5088 //--- preimage of (principal ideal) id2 was zero, i.e. 5089 //--- generator of previous id2 not in image 5090 setring S; 5091 //--- it might just be one offending factor ==> factorize 5092 ideal id2factors=factorize(id2[1])[1]; 5093 int zzz=size(id2factors); 5094 ideal curfactor; 5095 setring T; 5096 id2=ideal(1); 5097 ideal curfactor; 5098 for(int mm=1;mm<=zzz;mm++) 5099 { 5100 //--- blow down each factor separately 5101 setring S; 5102 curfactor=id2factors[mm]; 5103 setring T; 5104 curfactor=preimage(S,phi,curfactor); 5105 if(size(curfactor)>0) 5106 { 5107 id2[1]=id2[1]*curfactor[1]; 5108 } 5109 } 5110 kill curfactor; 5111 setring S; 5112 kill curfactor; 5113 kill id2factors; 5114 setring T; 5115 kill mm; 5116 kill zzz; 5117 if(defined(debug_fetchInTree)>0) 5118 { 5119 "corrected id2:"; 5120 id2; 5121 } 5122 } 5028 5123 idlist[m]=list(id1,id2,nE); 5029 5124 kill id1,id2; … … 5035 5130 for(m=1;m<=size(idlist);m++) 5036 5131 { 5132 //!!! Duplicate Block!!! All changes also needed above!!! 5133 //!!! no subprocedure due to large data overhead!!! 5134 //--- run through all ideals to be fetched 5037 5135 if(defined(id1)) {kill id1;} 5038 5136 if(defined(id2)) {kill id2;} … … 5045 5143 for(i=branchPos-1;i<=size(BO[4]);i++) 5046 5144 { 5145 //--- run through all relevant exceptional divisors 5047 5146 if(size(reduce(BO[4][i],std(id1)))==0) 5048 5147 { 5148 //--- V(id1) is contained in except. div. i in this chart 5049 5149 if(size(reduce(id1,std(BO[4][i])))!=0) 5050 5150 { 5151 //--- V(id1) does not equal except. div. i of this chart 5051 5152 if(defined(Etemp)) {kill Etemp;} 5052 5153 ideal Etemp=BO[4][i]; 5053 5154 if(npars(basering)>0) 5054 5155 { 5156 //--- we are in an algebraic extension of the base field 5055 5157 if(defined(prtemp)){kill prtemp;} 5056 list prtemp=minAssGTZ(BO[4][i]); 5158 list prtemp=minAssGTZ(BO[4][i]); // C-comp.except.div. 5057 5159 if(size(prtemp)>1) 5058 5160 { 5161 //--- more than 1 component 5059 5162 Etemp=ideal(1); 5060 5163 for(j=1;j<=size(prtemp);j++) 5061 5164 { 5165 //--- find correct component 5062 5166 if(size(reduce(prtemp[j],std(id1)))==0) 5063 5167 { … … 5071 5175 } 5072 5176 } 5177 prtemp=delete(prtemp,j); // remove this comp. from list 5178 while(size(prtemp)>1) 5179 { 5180 //--- collect all the others into prtemp[1] 5181 prtemp[1]=intersect(prtemp[1],prtemp[size(prtemp)]); 5182 prtemp=delete(prtemp,size(prtemp)); 5183 } 5073 5184 } 5074 5185 if(defined(tli)) {kill tli;} 5186 //--- determine tli[1] and tli[2] such that 5187 //--- V(id1) \cap D(id2) = V(tli[1]) \cap D(tli[2]) \cap BO[4][i] 5188 //--- inside V(BO[1]) (and if necessary inside V(BO[1]+BO[2])) 5075 5189 if(inJ) 5076 5190 { 5077 def tli=findTrans(id1+BO[2] ,Etemp,notE,BO[2]);5191 def tli=findTrans(id1+BO[2]+BO[1],Etemp,notE,BO[2]); 5078 5192 } 5079 5193 else 5080 5194 { 5081 def tli=findTrans(id1 ,Etemp,notE);5195 def tli=findTrans(id1+BO[1],Etemp,notE); 5082 5196 } 5197 if(npars(basering)>0) 5198 { 5199 //--- in algebraic extension: make sure we stay outside the other components 5200 if(size(prtemp)>0) 5201 { 5202 for(j=1;j<=ncols(prtemp[1]);j++) 5203 { 5204 //--- find the (univariate) generator of prtemp[1] which is the remaining 5205 //--- factor from the factorization over the extension field 5206 if(size(reduce(prtemp[1][j],std(id1)))>0) 5207 { 5208 tli[2]=tli[2]*prtemp[1][j]; 5209 } 5210 } 5211 } 5212 } 5083 5213 } 5084 5214 else … … 5107 5237 idlist[m][3]=nE; 5108 5238 } 5239 //!!! End of Duplicate Block !!!! 5109 5240 } 5110 5241 kill S; … … 5115 5246 } 5116 5247 } 5248 if(defined(debug_fetchInTree)>0) 5249 { 5250 "idlist after current blow down step:"; 5251 idlist; 5252 } 5253 } 5254 if(defined(debug_fetchInTree)>0) 5255 { 5256 "Blowing down ended"; 5117 5257 } 5118 5258 //---------------------------------------------------------------------------- … … 5122 5262 if(m1==comPa) 5123 5263 { 5264 //--- no further blow ups needed 5124 5265 if(size(algext)==0) 5125 5266 { 5267 //--- no field extension ==> we are done 5126 5268 return(idlist[1][1]); 5127 5269 } 5128 5270 else 5129 5271 { 5272 //--- field extension ==> we need to encode the result 5130 5273 list retlist; 5131 5274 for(m=1;m<=size(idlist);m++) … … 5136 5279 } 5137 5280 } 5281 //--- we need to blow up 5138 5282 if(defined(path_m1)) { kill path_m1; } 5139 5283 matrix path_m1=imap(Sm1,path); … … 5150 5294 while(i<size(path_togo)) 5151 5295 { 5296 //--- we need to blow up following the path path_togo through the tree 5152 5297 def S=basering; 5153 5298 if(defined(T)){kill T;} 5154 5299 if(size(algext)>0) 5155 5300 { 5301 //--- in an algebraic extension of the base field 5156 5302 if(defined(T0)){kill T0;} 5157 5303 def T0=L[2][path_togo[i+1]]; … … 5169 5315 map phi=S,lastMap; 5170 5316 list idlist=phi(idlist); 5317 if(defined(debug_fetchInTree)>0) 5318 { 5319 "in blowing up (algebraic extension case):"; 5320 phi; 5321 idlist; 5322 } 5171 5323 } 5172 5324 else … … 5180 5332 idlist[1][1]=radical(idlist[1][1]); 5181 5333 idlist[1][2]=radical(idlist[1][2]); 5334 if(defined(debug_fetchInTree)>0) 5335 { 5336 "in blowing up (case without field extension):"; 5337 phi; 5338 idlist; 5339 } 5182 5340 } 5183 5341 for(m=1;m<=size(idlist);m++) 5184 5342 { 5343 //--- get rid of new exceptional divisor 5185 5344 idlist[m][1]=sat(idlist[m][1]+BO[1],BO[4][size(BO[4])])[1]; 5186 5345 idlist[m][2]=sat(idlist[m][2],BO[4][size(BO[4])])[1]; 5346 } 5347 if(defined(debug_fetchInTree)>0) 5348 { 5349 "after saturation:"; 5350 idlist; 5187 5351 } 5188 5352 if((size(algext)==0)&&(deg(std(idlist[1][1])[1])==0)) … … 5195 5359 i++; 5196 5360 } 5361 if(defined(debug_fetchInTree)>0) 5362 { 5363 "End of blowing up steps"; 5364 } 5365 //--------------------------------------------------------------------------- 5366 // prepare results for returning them 5367 //--------------------------------------------------------------------------- 5197 5368 ideal E,bla; 5198 5369 intvec kv;
Note: See TracChangeset
for help on using the changeset viewer.
