[80ca3c] | 1 | #define PLURAL_INTERNAL_DECLARATIONS |
---|
| 2 | |
---|
[762407] | 3 | #include "config.h" |
---|
[e63576] | 4 | #include "mod2.h" |
---|
| 5 | #include <misc/auxiliary.h> |
---|
| 6 | |
---|
| 7 | #include <misc/options.h> |
---|
| 8 | |
---|
| 9 | #include <polys/simpleideals.h> |
---|
| 10 | #include <polys/prCopy.h> |
---|
[80ca3c] | 11 | #include <polys/nc/gb_hack.h> |
---|
[e63576] | 12 | |
---|
[80ca3c] | 13 | #include <kernel/polys.h> |
---|
[e63576] | 14 | |
---|
[80ca3c] | 15 | #include <kernel/ideals.h> |
---|
| 16 | #include <kernel/kstd1.h> |
---|
| 17 | |
---|
| 18 | #include <kernel/nc.h> |
---|
[e63576] | 19 | |
---|
| 20 | ideal twostd(ideal I) // works in currRing only! |
---|
| 21 | { |
---|
| 22 | ideal J = kStd(I, currQuotient, testHomog, NULL, NULL, 0, 0, NULL); // in currRing!!! |
---|
| 23 | idSkipZeroes(J); // ring independent! |
---|
| 24 | |
---|
| 25 | const int rN = currRing->N; |
---|
| 26 | |
---|
| 27 | loop |
---|
| 28 | { |
---|
| 29 | ideal K = NULL; |
---|
| 30 | const int s = idElem(J); // ring independent |
---|
| 31 | |
---|
| 32 | for(int i = 0; i < s; i++) |
---|
| 33 | { |
---|
| 34 | const poly p = J->m[i]; |
---|
| 35 | |
---|
| 36 | #ifdef PDEBUG |
---|
| 37 | p_Test(p, currRing); |
---|
| 38 | #if 0 |
---|
| 39 | Print("p: "); // ! |
---|
| 40 | p_Write(p, currRing); |
---|
| 41 | #endif |
---|
| 42 | #endif |
---|
| 43 | |
---|
| 44 | for (int j = 1; j <= rN; j++) // for all j = 1..N |
---|
| 45 | { |
---|
| 46 | poly varj = p_One( currRing); |
---|
| 47 | p_SetExp(varj, j, 1, currRing); |
---|
| 48 | p_Setm(varj, currRing); |
---|
| 49 | |
---|
| 50 | poly q = pp_Mult_mm(p, varj, currRing); // q = J[i] * var(j), |
---|
| 51 | |
---|
| 52 | #ifdef PDEBUG |
---|
| 53 | p_Test(varj, currRing); |
---|
| 54 | p_Test(p, currRing); |
---|
| 55 | p_Test(q, currRing); |
---|
| 56 | #if 0 |
---|
| 57 | Print("Reducing p: "); // ! |
---|
| 58 | p_Write(p, currRing); |
---|
| 59 | Print("With q: "); // ! |
---|
| 60 | p_Write(q, currRing); |
---|
| 61 | #endif |
---|
| 62 | #endif |
---|
| 63 | |
---|
| 64 | p_Delete(&varj, currRing); |
---|
| 65 | |
---|
| 66 | if (q != NULL) |
---|
| 67 | { |
---|
| 68 | #ifdef PDEBUG |
---|
| 69 | #if 0 |
---|
| 70 | Print("Reducing q[j = %d]: ", j); // ! |
---|
| 71 | p_Write(q, currRing); |
---|
| 72 | |
---|
| 73 | Print("With p:"); |
---|
| 74 | p_Write(p, currRing); |
---|
| 75 | |
---|
| 76 | #endif |
---|
| 77 | #endif |
---|
| 78 | |
---|
| 79 | // bug: lm(p) may not divide lm(p * var(i)) in a SCA! |
---|
| 80 | if( p_LmDivisibleBy(p, q, currRing) ) |
---|
| 81 | q = nc_ReduceSpoly(p, q, currRing); |
---|
| 82 | |
---|
| 83 | |
---|
| 84 | #ifdef PDEBUG |
---|
| 85 | p_Test(q, currRing); |
---|
| 86 | #if 0 |
---|
| 87 | Print("reductum q/p: "); |
---|
| 88 | p_Write(q, currRing); |
---|
| 89 | |
---|
| 90 | // Print("With J!\n"); |
---|
| 91 | #endif |
---|
| 92 | #endif |
---|
| 93 | |
---|
| 94 | // if( q != NULL) |
---|
| 95 | q = kNF(J, currQuotient, q, 0, KSTD_NF_NONORM); // in currRing!!! |
---|
| 96 | |
---|
| 97 | #ifdef PDEBUG |
---|
| 98 | p_Test(q, currRing); |
---|
| 99 | #if 0 |
---|
| 100 | Print("NF(J/currQuotient)=> q: "); // ! |
---|
| 101 | p_Write(q, currRing); |
---|
| 102 | #endif |
---|
| 103 | #endif |
---|
| 104 | if (q!=NULL) |
---|
| 105 | { |
---|
| 106 | if (p_IsConstant(q, currRing)) // => return (1)! |
---|
| 107 | { |
---|
| 108 | p_Delete(&q, currRing); |
---|
| 109 | id_Delete(&J, currRing); |
---|
| 110 | |
---|
| 111 | if (K != NULL) |
---|
| 112 | id_Delete(&K, currRing); |
---|
| 113 | |
---|
| 114 | ideal Q = idInit(1,1); // ring independent! |
---|
| 115 | Q->m[0] = p_One(currRing); |
---|
| 116 | |
---|
| 117 | return(Q); |
---|
| 118 | } |
---|
| 119 | |
---|
| 120 | // flag = false; |
---|
| 121 | |
---|
| 122 | // K += q: |
---|
| 123 | |
---|
| 124 | ideal Q = idInit(1,1); // ring independent |
---|
| 125 | Q->m[0]=q; |
---|
| 126 | |
---|
| 127 | if( K == NULL ) |
---|
| 128 | K = Q; |
---|
| 129 | else |
---|
| 130 | { |
---|
| 131 | ideal id_tmp = idSimpleAdd(K, Q); // in currRing |
---|
| 132 | id_Delete(&K, currRing); |
---|
| 133 | id_Delete(&Q, currRing); |
---|
| 134 | K = id_tmp; // K += Q |
---|
| 135 | } |
---|
| 136 | } |
---|
| 137 | |
---|
| 138 | |
---|
| 139 | } // if q != NULL |
---|
| 140 | } // for all variables |
---|
| 141 | |
---|
| 142 | } |
---|
| 143 | |
---|
| 144 | if (K == NULL) // nothing new: i.e. all elements are two-sided |
---|
| 145 | return(J); |
---|
| 146 | // now we update GrBasis J with K |
---|
| 147 | // iSize=IDELEMS(J); |
---|
| 148 | #ifdef PDEBUG |
---|
| 149 | idTest(J); // in currRing! |
---|
| 150 | #if 0 |
---|
| 151 | Print("J:"); |
---|
| 152 | idPrint(J); |
---|
| 153 | PrintLn(); |
---|
| 154 | #endif // debug |
---|
| 155 | #endif |
---|
| 156 | |
---|
| 157 | |
---|
| 158 | |
---|
| 159 | #ifdef PDEBUG |
---|
| 160 | idTest(K); // in currRing! |
---|
| 161 | #if 0 |
---|
| 162 | Print("+K:"); |
---|
| 163 | idPrint(K); |
---|
| 164 | PrintLn(); |
---|
| 165 | #endif // debug |
---|
| 166 | #endif |
---|
| 167 | |
---|
| 168 | |
---|
| 169 | int iSize = idElem(J); // ring independent |
---|
| 170 | |
---|
| 171 | // J += K: |
---|
| 172 | ideal id_tmp = idSimpleAdd(J,K); // in currRing |
---|
| 173 | id_Delete(&K, currRing); id_Delete(&J, currRing); |
---|
| 174 | |
---|
| 175 | #if 1 |
---|
[d30a399] | 176 | BITSET save1; |
---|
| 177 | SI_SAVE_OPT1(save1); |
---|
| 178 | si_opt_1|=Sy_bit(OPT_SB_1); // ring independent |
---|
[e63576] | 179 | J = kStd(id_tmp, currQuotient, testHomog, NULL, NULL, 0, iSize); // J = J + K, J - std // in currRing! |
---|
[d30a399] | 180 | SI_RESTORE_OPT1(save1); |
---|
[e63576] | 181 | #else |
---|
| 182 | J=kStd(id_tmp, currQuotient,testHomog,NULL,NULL,0,0,NULL); |
---|
| 183 | #endif |
---|
| 184 | |
---|
| 185 | id_Delete(&id_tmp, currRing); |
---|
| 186 | idSkipZeroes(J); // ring independent |
---|
| 187 | |
---|
| 188 | #ifdef PDEBUG |
---|
| 189 | idTest(J); // in currRing! |
---|
| 190 | #if 0 |
---|
| 191 | Print("J:"); |
---|
| 192 | idPrint(J); |
---|
| 193 | PrintLn(); |
---|
| 194 | #endif // debug |
---|
| 195 | #endif |
---|
| 196 | } // loop |
---|
| 197 | } |
---|
| 198 | |
---|
| 199 | |
---|
| 200 | |
---|
| 201 | |
---|
| 202 | static ideal idPrepareStd(ideal T, ideal s, int k) |
---|
| 203 | { |
---|
| 204 | // T is a left SB, without zeros, s is a list with zeros |
---|
| 205 | #ifdef PDEBUG |
---|
| 206 | if (IDELEMS(s)!=IDELEMS(T)) |
---|
| 207 | { |
---|
| 208 | Print("ideals of diff. size!!!"); |
---|
| 209 | } |
---|
| 210 | #endif |
---|
| 211 | ideal t = idCopy(T); |
---|
| 212 | int j,rs=id_RankFreeModule(s, currRing); |
---|
| 213 | poly p,q; |
---|
| 214 | |
---|
| 215 | ideal res = idInit(2*idElem(t),1+idElem(t)); |
---|
| 216 | if (rs == 0) |
---|
| 217 | { |
---|
| 218 | for (j=0; j<IDELEMS(t); j++) |
---|
| 219 | { |
---|
| 220 | if (s->m[j]!=NULL) pSetCompP(s->m[j],1); |
---|
| 221 | if (t->m[j]!=NULL) pSetCompP(t->m[j],1); |
---|
| 222 | } |
---|
| 223 | k = si_max(k,1); |
---|
| 224 | } |
---|
| 225 | for (j=0; j<IDELEMS(t); j++) |
---|
| 226 | { |
---|
| 227 | if (s->m[j]!=NULL) |
---|
| 228 | { |
---|
| 229 | p = s->m[j]; |
---|
| 230 | q = pOne(); |
---|
| 231 | pSetComp(q,k+1+j); |
---|
| 232 | pSetmComp(q); |
---|
| 233 | #if 0 |
---|
| 234 | while (pNext(p)) pIter(p); |
---|
| 235 | pNext(p) = q; |
---|
| 236 | #else |
---|
| 237 | p = pAdd(p,q); |
---|
| 238 | s->m[j] = p; |
---|
| 239 | #ifdef PDEBUG |
---|
| 240 | pTest(p); |
---|
| 241 | #endif |
---|
| 242 | #endif |
---|
| 243 | } |
---|
| 244 | } |
---|
| 245 | res = idSimpleAdd(t,s); |
---|
| 246 | idDelete(&t); |
---|
| 247 | res->rank = 1+idElem(T); |
---|
| 248 | return(res); |
---|
| 249 | } |
---|
| 250 | |
---|
| 251 | |
---|
| 252 | ideal Approx_Step(ideal L) |
---|
| 253 | { |
---|
| 254 | int N=currRing->N; |
---|
| 255 | int i,j; // k=syzcomp |
---|
| 256 | int flag, flagcnt=0, syzcnt=0; |
---|
| 257 | int syzcomp = 0; |
---|
| 258 | ideal I = kStd(L, currQuotient,testHomog,NULL,NULL,0,0,NULL); |
---|
| 259 | idSkipZeroes(I); |
---|
| 260 | ideal s_I; |
---|
| 261 | int idI = idElem(I); |
---|
| 262 | ideal trickyQuotient; |
---|
| 263 | if (currQuotient !=NULL) |
---|
| 264 | { |
---|
| 265 | trickyQuotient = idSimpleAdd(currQuotient,I); |
---|
| 266 | } |
---|
| 267 | else |
---|
| 268 | trickyQuotient = I; |
---|
| 269 | idSkipZeroes(trickyQuotient); |
---|
| 270 | poly *var = (poly *)omAlloc0((N+1)*sizeof(poly)); |
---|
| 271 | // poly *W = (poly *)omAlloc0((2*N+1)*sizeof(poly)); |
---|
| 272 | resolvente S = (resolvente)omAlloc0((N+1)*sizeof(ideal)); |
---|
| 273 | ideal SI, res; |
---|
| 274 | matrix MI; |
---|
| 275 | poly x=pOne(); |
---|
| 276 | var[0]=x; |
---|
[d30a399] | 277 | ideal h2, s_h2, s_h3; |
---|
| 278 | poly p,q; |
---|
[e63576] | 279 | // init vars |
---|
| 280 | for (i=1; i<=N; i++ ) |
---|
| 281 | { |
---|
| 282 | x = pOne(); |
---|
| 283 | pSetExp(x,i,1); |
---|
| 284 | pSetm(x); |
---|
| 285 | var[i]=pCopy(x); |
---|
| 286 | } |
---|
| 287 | // init NF's |
---|
| 288 | for (i=1; i<=N; i++ ) |
---|
| 289 | { |
---|
| 290 | h2 = idInit(idI,1); |
---|
| 291 | flag = 0; |
---|
| 292 | for (j=0; j< idI; j++ ) |
---|
| 293 | { |
---|
| 294 | q = pp_Mult_mm(I->m[j],var[i],currRing); |
---|
| 295 | q = kNF(I,currQuotient,q,0,0); |
---|
| 296 | if (q!=0) |
---|
| 297 | { |
---|
| 298 | h2->m[j]=pCopy(q); |
---|
| 299 | // p_Shift(&(h2->m[flag]),1, currRing); |
---|
| 300 | flag++; |
---|
| 301 | pDelete(&q); |
---|
| 302 | } |
---|
| 303 | else |
---|
| 304 | h2->m[j]=0; |
---|
| 305 | } |
---|
| 306 | // W[1..idElems(I)] |
---|
| 307 | if (flag >0) |
---|
| 308 | { |
---|
| 309 | // compute syzygies with values in I |
---|
| 310 | // idSkipZeroes(h2); |
---|
| 311 | // h2 = idSimpleAdd(h2,I); |
---|
| 312 | // h2->rank=flag+idI+1; |
---|
| 313 | idTest(h2); |
---|
| 314 | //idShow(h2); |
---|
| 315 | ring orig_ring = currRing; |
---|
| 316 | ring syz_ring = rAssure_SyzComp(orig_ring, TRUE); |
---|
| 317 | syzcomp = 1; |
---|
| 318 | rSetSyzComp(syzcomp, syz_ring); |
---|
| 319 | if (orig_ring != syz_ring) |
---|
| 320 | { |
---|
| 321 | rChangeCurrRing(syz_ring); |
---|
| 322 | s_h2=idrCopyR_NoSort(h2,orig_ring, syz_ring); |
---|
| 323 | // s_trickyQuotient=idrCopyR_NoSort(trickyQuotient,orig_ring); |
---|
| 324 | // rDebugPrint(syz_ring); |
---|
| 325 | s_I=idrCopyR_NoSort(I,orig_ring, syz_ring); |
---|
| 326 | } |
---|
| 327 | else |
---|
| 328 | { |
---|
| 329 | s_h2 = h2; |
---|
| 330 | s_I = I; |
---|
| 331 | // s_trickyQuotient=trickyQuotient; |
---|
| 332 | } |
---|
| 333 | idTest(s_h2); |
---|
| 334 | // idTest(s_trickyQuotient); |
---|
| 335 | Print(".proceeding with the variable %d\n",i); |
---|
| 336 | s_h3 = idPrepareStd(s_I, s_h2, 1); |
---|
[d30a399] | 337 | BITSET save1; |
---|
| 338 | SI_SAVE_OPT1(save1); |
---|
| 339 | si_opt_1|=Sy_bit(OPT_SB_1); |
---|
[e63576] | 340 | idTest(s_h3); |
---|
| 341 | idDelete(&s_h2); |
---|
| 342 | s_h2=idCopy(s_h3); |
---|
| 343 | idDelete(&s_h3); |
---|
| 344 | Print("...computing Syz"); |
---|
| 345 | s_h3 = kStd(s_h2, currQuotient,(tHomog)FALSE,NULL,NULL,syzcomp,idI); |
---|
[d30a399] | 346 | SI_RESTORE_OPT1(save1); |
---|
[e63576] | 347 | //idShow(s_h3); |
---|
| 348 | if (orig_ring != syz_ring) |
---|
| 349 | { |
---|
| 350 | idDelete(&s_h2); |
---|
| 351 | for (j=0; j<IDELEMS(s_h3); j++) |
---|
| 352 | { |
---|
| 353 | if (s_h3->m[j] != NULL) |
---|
| 354 | { |
---|
| 355 | if (p_MinComp(s_h3->m[j],syz_ring) > syzcomp) // i.e. it is a syzygy |
---|
| 356 | p_Shift(&s_h3->m[j], -syzcomp, currRing); |
---|
| 357 | else |
---|
| 358 | pDelete(&s_h3->m[j]); |
---|
| 359 | } |
---|
| 360 | } |
---|
| 361 | idSkipZeroes(s_h3); |
---|
| 362 | s_h3->rank -= syzcomp; |
---|
| 363 | rChangeCurrRing(orig_ring); |
---|
| 364 | // s_h3 = idrMoveR_NoSort(s_h3, syz_ring, orig_ring); |
---|
| 365 | s_h3 = idrMoveR_NoSort(s_h3, syz_ring, orig_ring); |
---|
[5fe834] | 366 | rDelete(syz_ring); |
---|
[e63576] | 367 | } |
---|
| 368 | idTest(s_h3); |
---|
| 369 | S[syzcnt]=kStd(s_h3,currQuotient,(tHomog)FALSE,NULL,NULL); |
---|
| 370 | syzcnt++; |
---|
| 371 | idDelete(&s_h3); |
---|
| 372 | } // end if flag >0 |
---|
| 373 | else |
---|
| 374 | { |
---|
| 375 | flagcnt++; |
---|
| 376 | } |
---|
| 377 | } |
---|
| 378 | if (flagcnt == N) |
---|
| 379 | { |
---|
| 380 | Print("the input is a two--sided ideal"); |
---|
| 381 | return(I); |
---|
| 382 | } |
---|
| 383 | if (syzcnt >0) |
---|
| 384 | { |
---|
| 385 | Print("..computing Intersect of %d modules\n",syzcnt); |
---|
| 386 | if (syzcnt == 1) |
---|
| 387 | SI = S[0]; |
---|
| 388 | else |
---|
| 389 | SI = idMultSect(S, syzcnt); |
---|
| 390 | //idShow(SI); |
---|
[d02a0a1] | 391 | MI = id_Module2Matrix(SI,currRing); |
---|
[e63576] | 392 | res= idInit(MATCOLS(MI),1); |
---|
| 393 | for (i=1; i<= MATCOLS(MI); i++) |
---|
| 394 | { |
---|
| 395 | p = NULL; |
---|
| 396 | for (j=0; j< idElem(I); j++) |
---|
| 397 | { |
---|
| 398 | q = pCopy(MATELEM(MI,j+1,i)); |
---|
| 399 | if (q!=NULL) |
---|
| 400 | { |
---|
| 401 | q = pMult(q,pCopy(I->m[j])); |
---|
| 402 | p = pAdd(p,q); |
---|
| 403 | } |
---|
| 404 | } |
---|
| 405 | res->m[i-1]=p; |
---|
| 406 | } |
---|
| 407 | Print("final std"); |
---|
| 408 | res = kStd(res, currQuotient,testHomog,NULL,NULL,0,0,NULL); |
---|
| 409 | idSkipZeroes(res); |
---|
| 410 | return(res); |
---|
| 411 | } |
---|
| 412 | else |
---|
| 413 | { |
---|
| 414 | Print("No syzygies"); |
---|
| 415 | return(I); |
---|
| 416 | } |
---|
| 417 | } |
---|