Changeset 62e2d6 in git


Ignore:
Timestamp:
May 8, 2000, 5:52:50 PM (23 years ago)
Author:
Gerhard Pfister <pfister@…>
Branches:
(u'spielwiese', 'f6c3dc58b0df4bd712574325fe76d0626174ad97')
Children:
8cd4dfcd0c10c84e83c8f1397608fde5aad6a384
Parents:
d8d3af1ae834e369741c0b81c50c210a25ce232e
Message:
equidimensionale Zerlegung eingefuegt


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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/normal.lib

    rd8d3af r62e2d6  
    55///////////////////////////////////////////////////////////////////////////////
    66
    7 version="$Id: normal.lib,v 1.21 1999-11-17 13:53:15 pfister Exp $";
     7version="$Id: normal.lib,v 1.22 2000-05-08 15:52:50 pfister Exp $";
    88info="
    99LIBRARY:  normal.lib     PROCEDURES FOR NORMALIZATION
     
    377377proc normal(ideal id, list #)
    378378"USAGE:   normal(i [,choose]);  i a radical ideal, choose empty or 1
    379          if choose=1 the factorizing Buchberger algorithm is not used
     379         if choose=1 the normalization of the associated primes is computed
    380380         (which is sometimes more efficient)
    381381RETURN:  a list of rings (say nor), in each ring nor[i] are two ideals
     
    405405     return(result);
    406406   }
    407 
     407   if( typeof(attrib(id,"isCompleteIntersection"))=="int" )
     408   {
     409      if(attrib(id,"isCompleteIntersection")==1)
     410      {
     411         attrib(id,"isCohenMacaulay",1);
     412         attrib(id,"isEquidimensional",1);
     413      }
     414   }       
     415   if( typeof(attrib(id,"isCohenMacaulay"))=="int" )
     416   {
     417      if(attrib(id,"isCohenMacaulay")==1)
     418      {
     419         attrib(id,"isEquidimensional",1);
     420      }
     421   }       
     422   if( typeof(attrib(id,"isPrim"))=="int" )
     423   {
     424      if(attrib(id,"isPrim")==1)
     425      {
     426         attrib(id,"isEquidimensional",1);
     427      }
     428   }       
    408429   if(size(#)==0)
    409 //--------------- the factorizing Buchberger algorithm is used ---------------
    410    {
    411       prim[1]=id;
     430   {
    412431      if( typeof(attrib(id,"isEquidimensional"))=="int" )
    413432      {
    414         if(attrib(id,"isEquidimensional")==1)
    415         {
    416            attrib(prim[1],"isEquidimensional",1);
    417         }
    418       }
    419       else
    420       {
    421          attrib(prim[1],"isEquidimensional",0);
    422       }
    423       if( typeof(attrib(id,"isCompleteIntersection"))=="int" )
    424       {
    425         if(attrib(id,"isCompleteIntersection")==1)
    426         {
    427            attrib(prim[1],"isCompleteIntersection",1);
    428         }
    429       }
    430       else
    431       {
    432          attrib(prim[1],"isCompleteIntersection",0);
    433       }
    434 
    435       if( typeof(attrib(id,"isPrim"))=="int" )
    436       {
    437         if(attrib(id,"isPrim")==1)  {attrib(prim[1],"isPrim",1); }
    438       }
    439       else
    440       {
    441          attrib(prim[1],"isPrim",0);
    442       }
    443       if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
    444       {
    445          if(attrib(id,"isIsolatedSingularity")==1)
    446              {attrib(prim[1],"isIsolatedSingularity",1); }
    447       }
    448       else
    449       {
    450          attrib(prim[1],"isIsolatedSingularity",0);
    451       }
    452       if( typeof(attrib(id,"isCohenMacaulay"))=="int" )
    453       {
    454          if(attrib(id,"isCohenMacaulay")==1)
    455            { attrib(prim[1],"isCohenMacaulay",1); }
    456       }
    457       else
    458       {
    459          attrib(prim[1],"isCohenMacaulay",0);
    460       }
    461       if( typeof(attrib(id,"isRegInCodim2"))=="int" )
    462       {
    463          if(attrib(id,"isRegInCodim2")==1)
    464          { attrib(prim[1],"isRegInCodim2",1);}
    465       }
    466       else
    467       {
    468           attrib(prim[1],"isRegInCodim2",0);
    469       }
    470 
    471       result = normalizationPrimes(prim[1],maxideal(1));
    472       sr = string(size(result));
    473      
    474       dbprint(y+1,"
    475 // 'normal' created a list of "+sr+" ring(s).
    476 // To see the rings, type (if the name of your list is nor):
    477      show( nor);
    478 // To access the 1-st ring and map (and similair for the others), type:
    479      def R = nor[1]; setring R;  norid; normap;
    480 // R/norid is the 1-st ring of the normalization and
    481 // normap the map from the original basering to R/norid");
    482 
    483        return(result);
    484    }
    485    else
    486 //------------- the factorizing Buchberger algorithm is not used -------------
    487    {
    488       if(#[1]==0)
    489       {
    490          prim=minAssPrimes(id);
    491       }
    492       else
    493       {
    494          prim=minAssPrimes(id,1);
    495       }
    496 
    497       if(y>=1)
    498       {
    499          "// we have ",size(prim),"components";
    500       }
    501       for(i=1; i<=size(prim); i++)
    502       {
    503          if(y>=1)
     433         if(attrib(id,"isEquidimensional")==1)
    504434         {
    505             "// we are in loop ",i;
    506          }
    507          attrib(prim[i],"isCohenMacaulay",0);
    508          attrib(prim[i],"isPrim",1);
    509          attrib(prim[i],"isRegInCodim2",0);
    510          attrib(prim[i],"isIsolatedSingularity",0);
    511          attrib(prim[i],"isEquidimensional",0);
    512          attrib(prim[i],"isCompleteIntersection",0);
    513 
    514          if( typeof(attrib(id,"isEquidimensional"))=="int" )
    515          {
    516            if(attrib(id,"isEquidimensional")==1)
    517            {
    518               attrib(prim[i],"isEquidimensional",1);
    519            }
     435            prim[1]=id;
    520436         }
    521437         else
    522438         {
    523             attrib(prim[i],"isEquidimensional",0);
     439            prim=equidim(id);
    524440         }
    525          if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
     441      }
     442      else
     443      {
     444         prim=equidim(id);
     445      }
     446      if(y>=1)
     447      {
     448         "// we have ",size(prim),"equidimensional components";
     449      }
     450   }
     451   else
     452   { 
     453      if( typeof(attrib(id,"isPrim"))=="int" )
     454      {
     455         if(attrib(id,"isPrim")==1)
    526456         {
     457            prim[1]=id;
     458         }
     459         else
     460         {   
     461            prim=minAssPrimes(id);
     462         }
     463      }
     464      else
     465      {
     466         prim=minAssPrimes(id);
     467      }         
     468      if(y>=1)
     469      {
     470         "// we have ",size(prim),"irreducible components";
     471      }
     472   }
     473   for(i=1; i<=size(prim); i++)
     474   {
     475      if(y>=1)
     476      {
     477         "// we are in loop ",i;
     478      }
     479      attrib(prim[i],"isCohenMacaulay",0);
     480      if(size(#)!=0)
     481      {
     482         attrib(prim[i],"isPrim",1);
     483      }
     484      else
     485      {
     486         attrib(prim[i],"isPrim",0);
     487      }
     488      attrib(prim[i],"isRegInCodim2",0);
     489      attrib(prim[i],"isIsolatedSingularity",0);
     490      attrib(prim[i],"isEquidimensional",1);
     491      attrib(prim[i],"isCompleteIntersection",0);
     492
     493      if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
     494      {
    527495            if(attrib(id,"isIsolatedSingularity")==1)
    528496             {attrib(prim[i],"isIsolatedSingularity",1); }
    529          }
    530          else
    531          {
    532             attrib(prim[i],"isIsolatedSingularity",0);
    533          }
    534 
    535          keepresult=normalizationPrimes(prim[i],maxideal(1));
    536          for(j=1;j<=size(keepresult);j++)
    537          {
    538             result=insert(result,keepresult[j]);
    539          }
     497      }
     498
     499      if( typeof(attrib(id,"isCompleteIntersection"))=="int" )
     500      {
     501            if((attrib(id,"isIsolatedSingularity")==1)&&(size(#)==0))
     502             {attrib(prim[i],"isIsolatedSingularity",1); }
     503      }
     504      keepresult=normalizationPrimes(prim[i],maxideal(1));
     505      for(j=1;j<=size(keepresult);j++)
     506      {
     507         result=insert(result,keepresult[j]);
    540508      }
    541509      sr = string(size(result));
    542 
     510   }
    543511      dbprint(y+1,"
    544512// 'normal' created a list of "+sr+" ring(s).
     
    552520      //kill endphi,endid;
    553521      return(result);
    554    }
    555522}
    556523example
     
    618585     "// SB-computation of the input ideal";
    619586   }
     587   
    620588   list SM=mstd(i);                //here the work starts
    621589   int dimSM =  dim(SM[1]);
     
    688656      attrib(SM[2],"isRegInCodim2",0);
    689657   }
    690     if(attrib(i,"isEquidimensional")==1)
     658   if(attrib(i,"isEquidimensional")==1)
    691659   {
    692660      attrib(SM[2],"isEquidimensional",1);
     
    821789         dim(JM[1]); "";
    822790      }
    823 
    824791      attrib(JM[2],"isRad",0);
    825792      //   timer-ti;
     
    849816         attrib(SM[2],"isIsolatedSingularity",1);
    850817      }
    851       if(dim(JM[1])<=nvars(basering)-2)
     818      if(dim(JM[1])<=dim(SM[1])-2)
    852819      {
    853820         attrib(SM[2],"isRegInCodim2",1);
     
    862829        attrib(SM[2],"isRegInCodim2",1);
    863830     }
     831   }
     832   if((attrib(SM[2],"isRegInCodim2")==1)&&(attrib(SM[2],"isCohenMacaulay")==1))
     833   {     
     834      if(y>=1)
     835      {
     836            "// the ideal was CohenMacaulay and regular in codimension 2";
     837      }
     838      MB=SM[2];
     839      intvec rw;
     840      list LL=substpart(MB,ihp,0,rw);
     841      def newR6=LL[1];
     842      setring newR6;
     843      ideal norid=endid;
     844      ideal normap=endphi;
     845      kill endid,endphi;
     846      export norid;
     847      export normap;
     848      result=newR6;
     849      setring BAS;
     850      return(result);         
    864851   }
    865852   //if it is an isolated singularity things are easier
     
    12501237b6c+bc6+a2b4e-3ab2c2de+c4d2e-a3cde2-abd3e2+bce5;
    12511238
     1239int aa=timer;list nor=normal(i);timer-aa;
    12521240
    12531241//Vasconcelos
     
    12621250ring r=32003,(x,y,z),wp(2,3,6);
    12631251ideal i=zy2-zx3-x6;
     1252
     1253//Theo1a (CohenMacaulay and regular in codimension 2)
     1254ring r=32003,(x,y,z,u),wp(2,3,6,6);
     1255ideal i=zy2-zx3-x6+u2;
     1256
    12641257
    12651258//Theo2
     
    14121405puv2-puw;
    14131406
     1407ring r=0,(u,v,w,x,y,z),wp(1,1,1,3,2,1);
     1408ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2;
     1409
     1410
    14141411
    14151412*/
Note: See TracChangeset for help on using the changeset viewer.