Changeset 676724 in git


Ignore:
Timestamp:
Mar 19, 2001, 11:57:16 PM (23 years ago)
Author:
Gert-Martin Greuel <greuel@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'd25190065115c859833252500a64cfb7b11e3a50')
Children:
8c4269a2193d8ebf4d512ac0304fe2a3644f8533
Parents:
4e18c51925ab32021341e7172545db0b399b0eab
Message:
* GMG: normal.lib: normalizationPrimes voellig neu kommentiert
* Bei Berechnung des singulaeren Ortes das Minorenideal mit simplify(..,16)
* verkleinert. Das kann zwar ein kleinerse Ideal erzeugen (bei der
* anschliessenden mstd Berechnung hat sich aber nie ein Unterschied ergeben),
* das ist fuer diesen Algorithmus aber erlaubt. Bei kleinen Beispielen hat das
* keinen Unterschied gezeigt, bei grosse die Berechnung aber bis zum Faktor
* 10 beschleunigt.


git-svn-id: file:///usr/local/Singular/svn/trunk@5324 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/normal.lib

    r4e18c5 r676724  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: normal.lib,v 1.34 2001-02-22 09:25:01 lossen Exp $";
     2version="$Id: normal.lib,v 1.35 2001-03-19 22:57:16 greuel Exp $";
    33category="Commutative Algebra";
    44info="
     
    7171
    7272proc HomJJ (list Li)
    73 "USAGE:   HomJJ (Li);  Li = list: ideal SBid, ideal id, ideal J, poly p
     73"USAGE:   HomJJ (Li); Li list: ideal SBid, ideal id, ideal J, poly p, int count
    7474ASSUME:  R    = P/id,  P = basering, a polynomial ring, id an ideal of P,
    7575@*       SBid = standard basis of id,
    7676@*       J    = ideal of P containing the polynomial p,
    7777@*       p    = nonzero divisor of R
     78@*       count controls printlevel during recursive call
    7879COMPUTE: Endomorphism ring End_R(J)=Hom_R(J,J) with its ring structure as
    7980         affine ring, together with the canonical map R --> Hom_R(J,J),
     
    9293//---------- initialisation ---------------------------------------------------
    9394
    94    int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y;
     95   int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y,count;
    9596   intvec rw,rw1;
    9697   list L;
    97    y = printlevel-voice+2;  // y=printlevel (default: y=0)
     98   if(size(Li)>=5)
     99   {
     100     count = Li[5];
     101   }
     102   y = printlevel-voice+count; 
    98103 def P = basering;
    99104   ideal SBid, id, J = Li[1], Li[2], Li[3];
     
    147152   { "// the module p*Hom(J,J) = p*J:J, p a non-zerodivisor";
    148153      "// p"; p;
    149       "// f=p*J:J";f;
     154      "// f=p*J:J";
     155      if( y>=2 ) { f; }     
    150156   }
    151157   f2 = std(p);
     
    187193      attrib(endid,"isCompleteIntersection",0);
    188194      attrib(endid,"isRad",0);
    189 //      export endid;
    190 //      export endphi;
    191 //      L = newR1;
    192195      L=lastRing;
    193196      L = insert(L,1,1);
    194       dbprint(y,"// case R = Hom(J,J)");
    195197      if(y>=1)
    196198      {
    197          "//   R=Hom(J,J)";
     199         "// case R = Hom(J,J), we are ready with this component";
    198200         "   ";
    199          lastRing;
     201       if( y>=2 )
     202       {
     203        lastRing;
    200204         "   ";
    201205         "//   the new ideal";
    202          endid;
     206         if( y>=2 ) { endid; }
    203207         "   ";
    204208         "//   the old ring";
     
    218222         pause();
    219223         newline;
     224       }
    220225      }
    221226      setring P;
     
    225230   {
    226231      "// 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    }   
    229236   }
    230237//---------- Hom(J,J) != R: create new ring and map from old ring -------------
     
    279286      "//   the linear relations";
    280287      " ";
    281       Lin;
    282       "   ";
     288      if( y>=2 )
     289      {  Lin;     
     290         pause();
     291         "";
     292      }
    283293   }
    284294   for (ii=2; ii<=q; ii++ )
     
    293303   {
    294304      "//   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      }
    299312   }
    300313   Q = Lin+Quad;
     
    329342   {
    330343      "//   the new ring after reduction of the number of variables";
    331       "   ";
     344      show(lastRing);
     345      pause(); "
     346      ";
     347    if(y >=2)
     348    {
    332349      lastRing;
    333350      "   ";
     
    352369      pause();
    353370      newline;
     371    }
    354372   }
    355373   L = lastRing;
     
    391409@end format
    392410NOTE:    to use the i-th 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.
    395412@*       If the input ideal i is weighted homogeneous a weighted ordering may
    396413         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
    397418EXAMPLE: example normal; shows an example
    398419"
     
    452473      if(y>=1)
    453474      {
    454          "// we have ",size(prim),"equidimensional components";
     475        "";
     476         "// we have ",size(prim),"equidimensional component(s)";
    455477      }
    456478   }
     
    465487         else
    466488         {
    467             prim=minAssPrimes(id);
     489            prim=minAssGTZ(id);
    468490         }
    469491      }
    470492      else
    471493      {
    472          prim=minAssPrimes(id);
     494         prim=minAssGTZ(id);
    473495      }
    474496      if(y>=1)
    475497      {
    476          "// we have ",size(prim),"irreducible components";
     498         "";
     499         "// we have ",size(prim),"irreducible component(s)";
    477500      }
    478501   }
     
    481504      if(y>=1)
    482505      {
    483          "// we are in loop ",i;
     506         "";
     507         "// BEGIN with equidimensional/irreducible component",i;
    484508      }
    485509      attrib(prim[i],"isCohenMacaulay",0);
     
    508532             {attrib(prim[i],"isIsolatedSingularity",1); }
    509533      }
    510       keepresult=normalizationPrimes(prim[i],maxideal(1));
     534      keepresult=normalizationPrimes(prim[i],maxideal(1),0);
    511535      for(j=1;j<=size(keepresult);j++)
    512536      {
     
    518542// 'normal' created a list of "+sr+" ring(s).
    519543// To see the rings, type (if the name of your list is nor):
    520      show( nor);
     544     show(nor);
    521545// To access the 1-st ring and map (similar for the others), type:
    522546     def R = nor[1]; setring R;  norid; normap;
     
    540564
    541565///////////////////////////////////////////////////////////////////////////////
    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
     566static 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
    545570RETURN:  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
    547572         S is a standardbasis of M
    548573NOTE:    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
    550578EXAMPLE: example normalizationPrimes; shows an example
    551579"
    552580{
    553    int y = printlevel-voice+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 = printlevel-voice+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";  "";
    559590     i;  "";
    560591     basering;  "";
     
    562593     newline;
    563594   }
     595
    564596
    565597   def BAS=basering;
     
    588620   if(y>=1)
    589621   {
    590      "// SB-computation 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   "// SB-computation of ideal of size",size(i),"in ring with",nvars(basering),"variables";
     623   }
     624// -------------- SB-computation 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
    595628  // Case: Get an ideal containing a unit
    596629   if( dimSM == -1)
     
    620653   }
    621654
    622    if(size(#)>0)
     655   if(size(#)>0)                   //ideal of sing locus is given in #[1]
    623656   {
    624657      list JM=mstd(#[1]);
     
    629662   }
    630663
     664// -------- transfer attributes from ideal i to SM[2], SM = mstd(i) --------
    631665   if(attrib(i,"isPrim")==1)
    632666   {
     
    678712   }
    679713
    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 ----------------------------
    681718   if(size(#)>0)
    682719   {
     
    702739     }
    703740   }
    704 
    705    //the zero-dimensional 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 zero-dimensional case ----------------
    706746   if((dim(SM[1])==0)&&(homog(SM[2])==1))
    707747   {
     
    725765   }
    726766
    727    //the one-dimensional case
    728    //in this case it is a line because
    729    //it is irreducible and homogeneous
     767//------------- the homogeneous one-dimensional case -------------------
     768//in this case i defines a line because it is irreducible and homogeneous
    730769   if((dim(SM[1])==1)&&(attrib(SM[2],"isPrim")==1)
    731770        &&(homog(SM[2])==1))
     
    749788      return(result);
    750789   }
    751 
    752    //the higher dimensional case
     790//----------------------- the higher dimensional case ----------------------
    753791   //we test first of all CohenMacaulay and
    754792   //complete intersection
     
    766804
    767805   //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 normal-fehler" ,
    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 -------------------------
    779811      J=minor(jacob(SM[2]),nvars(basering)-dim(SM[1]));
    780812      //ti=timer;
    781813      if(y >=1 )
    782814      {
    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];
    789825      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
    792830      if(y>=1)
    793831      {
     
    817855         return(result);
    818856      }
    819       if(dim(JM[1])==0)
     857      if(dim(JM[1])==0 && (homog(SM[2])==1))
    820858      {
    821859         attrib(SM[2],"isIsolatedSingularity",1);
     
    826864      }
    827865   }
    828    else
     866   
     867//------------ case: isolated singularity and homogeneous -----------------
     868   if(attrib(SM[2],"isIsolatedSingularity")==1)   
    829869   {
    830870     if(size(#)==0)
    831871     {
    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        }
    834879        attrib(JM[1],"isSB",1);
    835         attrib(SM[2],"isRegInCodim2",1);
    836880     }
    837881   }
     882
     883//------------ case: Cohen Macaulay and regular in codim 2 -----------------
     884//in this case we are ready, the ring is normal 
    838885   if((attrib(SM[2],"isRegInCodim2")==1)&&(attrib(SM[2],"isCohenMacaulay")==1))
    839886   {
     
    856903      return(result);
    857904   }
    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
    859914   //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      }
    863923      ideal SL=simplify(reduce(maxideal(1),SM[1]),2);
    864            //vars not contained in ideal
     924      //SL = vars not contained in ideal
    865925      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);     
    868927      //qAnn=0 ==> the first var(=SL[1]) not contained in SM is a nzd of R/SM
     928  //--------------- case: a nonzero-divisor was found ---------------
    869929      if(size(qAnn)==0)
    870930      {
     
    872932         {
    873933            "";
     934            "//   a nonzero-divisor was found";
    874935            "//   the ideal rad(J):";
    875936            "";
    876937            maxideal(1);
    877938            newline;
     939            "// TEST for normality: R=Hom(J,J)?";
     940            "";
    878941         }
    879          //again test for normality
    880          //Hom(I,R)=R
     942    //test for normality:
     943         //?spaeter: test for normality, Hom(I,R)==R?
    881944         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         //  timer-ti;
     949         if(RR[2]==0)
     950    //the ring is not normal, start a new normalization loop
    886951         {
    887952            def newR=RR[1];
    888953            setring newR;
    889954            map psi=BAS,endphi;
    890          //   ti=timer;
    891             list tluser=normalizationPrimes(endid,psi(ihp));
    892 
    893         //    timer-ti;
     955         //  ti=timer;
     956            list tluser=normalizationPrimes(endid,psi(ihp),count);
     957         //  timer-ti;
    894958            setring BAS;
    895959            return(tluser);
    896960         }
     961    //the ring is normal, prepare output and go home
    897962         MB=SM[2];
    898963         execute("ring newR7="+charstr(basering)+",("+varstr(basering)+"),("
     
    903968         export normap;
    904969         result=newR7;
    905          // the following 2 lines don't work : nor is not defined
    906          //def R = nor[1]; setring R;     //make the 1-st ring the basering
    907          //norid; normap;                 //data of the normalization)
    908970         setring BAS;
    909971         return(result);
    910972
    911973       }
    912       //Now the case where qAnn!=0, i.e.SL[1] is a zero divisor of R/SM
     974  //--------------- case: a zero-divisor was found ---------------
     975      //Now the case where qAnn!=0, i.e.SL[1] is a zero-divisor of R/SM
    913976      //and we have found a splitting: id and id1
    914977      //id=qAnn+SM[2] defines components of R/SM in the complement of V(SL[1])
     
    917980       else
    918981       {
     982         if(y>=0)
     983         {
     984            "//   a zero-divisor was found, we have SPLITTING of ideals";
     985           if(y >=2 )
     986           {
     987             "// in ring:";
     988             show(basering);
     989            }
     990            "";
     991         }
     992         
    919993          ideal id=qAnn+SM[2];
    920994
     
    9261000          attrib(id,"isEquidimensional",0);
    9271001
    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);
    9291007          ideal id1=quotient(SM[2],Ann)+SM[2];
    9301008//          evtl. qAnn statt Ann nehmen
     
    9381016          attrib(id1,"isEquidimensional",0);
    9391017
    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);
    9411023
    9421024          for(lauf=1;lauf<=size(keepresult2);lauf++)
     
    9481030   }
    9491031
    950    //test for non-normality
    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 non-normality: 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      }
    9531046
    9541047   ideal SL=simplify(reduce(JM[2],SM[1]),2);
     1048   //SL = elements of ideal of singular locus not contained in ideal i
    9551049   ideal Ann=quotient(SM[2],SL[1]);
    9561050   ideal qAnn=simplify(reduce(Ann,SM[1]),2);
    957 
     1051   //qAnn=0 ==> SL[1] is a nonzero-divisor of R/SM
     1052
     1053  //--------------- case: a nonzero-divisor was found ---------------
    9581054   if(size(qAnn)==0)
    9591055   {
    9601056      list RR;
    9611057      list RS;
    962       //now we have to compute the radical
     1058    //now we have to compute the radical
    9631059      if(y>=1)
    9641060      {
    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 nonzero-divisor 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
    9701072      if(y>=1)
    9711073      {
    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)?";
    9741089        "";
    9751090      }
    9761091
    977       JM=J,J;
    978 
     1092      JM=J,J;              //J = new ideal for singular locus
    9791093      //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
    9901100      if(RS[2]==1)
    9911101      {
     
    10011111         return(lastR);
    10021112      }
     1113
     1114    //--- the ring is not normal, start a new normalization loop       
    10031115      int n=nvars(basering);
    10041116      ideal MJ=JM[2];
     
    10091121      map psi=BAS,endphi;
    10101122      list tluser=
    1011              normalizationPrimes(endid,psi(ihp),simplify(psi(MJ)+endid,4));
     1123           normalizationPrimes(endid,psi(ihp),count,simplify(psi(MJ)+endid,4));
    10121124      setring BAS;
    10131125      return(tluser);
    10141126   }
    1015     // A component with singular locus the whole component found
     1127  //--------------- case: a zero-divisor was found ---------------
     1128  //Now the case where qAnn!=0, i.e.SL[1] is a zero-divisor 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:
    10161135   if( Ann == 1)
    10171136   {
     
    10351154         return(result);
    10361155   }
     1156   // The general case with splitting of ring, i.e. qAnn!=0
    10371157   else
    10381158   {
     
    10411161      execute("ring newR1="+charstr(basering)+",("+varstr(basering)+"),("
    10421162                      +ordstr(basering)+");");
    1043       if(y>=1)
    1044       {
    1045          "// zero-divisor found";
     1163      if(y>=0)
     1164      {
     1165            "//   a zero-divisor was found, we have SPLITTING of ideals";
     1166            "";
    10461167      }
    10471168      ideal vid=fetch(BAS,new1);
     
    10611182      attrib(vid,"isCompleteIntersection",0);
    10621183
    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);
    10641190
    10651191      setring BAS;
     
    10851211      attrib(vid,"isCompleteIntersection",0);
    10861212
    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);
    10881219
    10891220      setring BAS;
     
    11091240   b6c+bc6+a2b4e-3ab2c2de+c4d2e-a3cde2-abd3e2+bce5;
    11101241
    1111    list pr=normalizationPrimes(i);
     1242   list pr=normalizationPrimes(i,maxideal(1),1);
    11121243   def r1=pr[1];
    11131244   setring r1;
     
    12161347/////////////////////////////////////////////////////////////////////////////
    12171348/*
     1349Aenderungen:
     13501. normal kommentiert, bei Berechnung de singulaeren Ortes ein simplify(J,16)
     1351eingefuehrt, um bei riesigen Minorenzahlen, das Ideal zu verkleinern (bis
     1352Faktor 10 Beschleunigung).
     1353Protokoll mit printlevel so gesteuert, dass es bei rekursivem Aufruf korrekt
     1354arbeitet.
     1355list nor = normal(i);     //mit equidim Zerlegung
     1356list nor = normal(i,1);   //mit prim Zerlegung
     1357Zeiten au sony_pumuckel (P2, 500)
    12181358                           Examples:
    12191359LIB"normal.lib";
    1220 //Huneke
     1360//1. Huneke, 1 Komponente
     1361//prim: 2 sec equidim:1sec
    12211362ring qr=31991,(a,b,c,d,e),dp;
    12221363ideal i=
     
    12311372
    12321373
    1233 //Vasconcelos (dauert laenger: 60 sec)
     1374//2. Vasconcelos (dauert laenger: 83 sec auf sony_pumuckel)
    12341375ring r=32003,(x,y,z,w,t),dp;
    12351376ideal i=
     
    12381379xw3+z3t+ywt2,
    12391380y2w4-xy2z2t-w3t3;
     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
     1385ring r=32003,(x,y,z,w,t),dp;
     1386ideal i=
     1387x+zw,
     1388y3+xwt,
     1389xw3+z3t+ywt2;
     1390
     1391//3. GM1
     1392// irreducible, 13 normalization loops, 1 Ring
     1393//2sec mit prim, 1 sec mit equidim
     1394ring r=32003,(x,y,z,u),dp;
     1395ideal i = x2+y3,z2+u3,y2+z3;
     1396
     1397//3a. GM1
     1398ring r=32003,(x,y),dp;
     1399ideal i = intersect(y3+x2,y2+x3);  // beide 0 sec
     1400ideal 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)
     1407ring r=32003,(x,y,z,u),dp;
     1408ideal 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)
     1413ring r=32003,(x,y,z,u),dp;
     1414ideal i =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y;
     1415
     1416//GM4
     1417//equidim: 2 equidim comp, 3 Ringe, (0sec);
     1418//prim: 3 Komp, (0sec)
     1419ring r=32003,(x,y,z,u),dp;
     1420ideal i1 = x2+y3,u,z;
     1421ideal i2 = u2+z3,x,y;
     1422ideal i3 = x2+y2+z2+u4;
     1423ideal 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)
     1429ring r=32003,(x,y,z,u),dp;
     1430ideal i1 = x2+y3,u,z;
     1431ideal i2 = u2+z3,x,y;
     1432ideal i3 = x2+y2+z2+u4;
     1433ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y;
     1434ideal i = intersect(i1,i2,i3,i4);
     1435
     1436//GM5
     1437//equidim: 4 Komp,0sec, prim 13 Komp, 1sec
     1438ring r=32003,(x,y,z,u,v),dp;
     1439ideal i1 = x2+y3,v;                            //2dim
     1440ideal i2 = u2+z3,x,y;                          //3dim
     1441ideal i3 = x2+y2+z2+u4;                        //4dim
     1442ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y; //1dim
     1443ideal i = intersect(i1,i2,i3,i4);
     1444
     1445//cyclic 5
     1446//equidim: 1 Komp 0sec, prim: 20 Komp, 3 sec
     1447ring r=32003,(x,y,z,u,v),dp;
     1448ideal i =
     1449x+y+z+u+v,
     1450xy+yz+zu+xv+uv,
     1451xyz+yzu+xyv+xuv+zuv,
     1452xyzu+xyzv+xyuv+xzuv+yzuv,
     1453xyzuv-1;
     1454
     1455// cyclic 5 hat Normalisierung (1 embim weniger)
     1456///equidim: 1 Komp 0sec, prim: 20 Komp, 2 sec
     1457ring r=32003,(x,y,z,u),dp;
     1458ideal i =
     1459x2+xz-yz+2xu+yu+u2,
     1460xy2-xyz+y2z-y2u+xzu+yzu+z2u-xu2-2yu2+zu2-u3,
     1461xyz2+xyzu+y2zu-xz2u+yz2u-z3u-xyu2-xzu2-2z2u2+xu3+yu3-zu3+u4,
     14622xyzu2+y2zu2+2yz2u2-xyu3-2xzu3-yzu3-z2u3+xu4+yu4-2zu4+u5-1;
     1463
     1464//cyclic(6)
     1465//equidim: 1Komp in 5 vars 1sec
     1466//prim: 90 (!) Ringe, 12 sec
    12401467
    12411468//Theo1
     
    12841511ad;
    12851512
    1286 //Beispiel, wo vorher Primaerzerlegung schneller (2 sec,sonst 860 sec)
     1513//Sturmfels, wo vorher Prim schneller (2 sec,sonst 860 sec)
    12871514//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
    12891519ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
    12901520ideal i=
     
    13171547tuy-bvz;
    13181548
    1319 //dauert laenger ohne Primaerzerlegung vorher (1 sec gegen
    13201549//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:
     1557ring r=31991,(a,b,c,d,e,f),dp;
    13221558ideal i=
    13231559adef-16000be2f+16001cef2,
     
    13561592
    13571593
    1358 ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
    1359 
     1594ring r=32003,(b,s,t,u,v,w,x,y,z),dp;   //3sec
    13601595ideal k=
    13611596wy-vz,
     
    13671602ideal i=mstd(intersect(j,k))[2];
    13681603
    1369 //22
     1604//22,
     1605// neu, prim: 3 sec, equidim 1 sec, je 4 Ringe
    13701606ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
    13711607ideal i=
     
    13771613
    13781614
    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
    13851618ring r=32000,(p,q,s,t,u,v,w,x,y,z),wp(1,1,1,1,1,1,2,1,1,1);
    13861619ideal i=
     
    13981631
    13991632ring 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,y3-x2;
     1633ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2;   //0sec
    14011634*/
    14021635
Note: See TracChangeset for help on using the changeset viewer.