Changeset 091424 in git for Singular/LIB/normal.lib


Ignore:
Timestamp:
Aug 3, 1999, 1:43:10 PM (25 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
80b3cd91bb34663c436c755f638ee6d91193bd1c
Parents:
3d276d2b96d8b91e89923453839edc84b93c91ed
Message:
* GMG:
22.9.99, 31.9.
Die folgenden von mir ueberarbeiteten Libs muessen neu eingecheckt
werden:

/home/greuel/Singular/Singular/LIB/algebra.lib
* GMG: new procedures:  noetherNormal(id),
* mapIsFinite(R,phi,I), finitenessTest(i,z),
* renaming (alg_kernel, algDependent)

/home/greuel/Singular/Singular/LIB/deform.lib
* GMG: cosmetics

/home/greuel/Singular/Singular/LIB/elim.lib
* GMG: new procedure: select1, better help text for select

/home/greuel/Singular/Singular/LIB/homolog.lib
* GMG: Author names added

/home/greuel/Singular/Singular/LIB/invar.lib
* GMG: procedure 'der' renamed to derivate

//in der lib alle Aufrufe von 'der' entsprechend geaendert.
//ausserhalb nicht.
//Die 'offizielle' ist durch matchen offenbar vermanscht!

/home/greuel/Singular/Singular/LIB/monodromy.lib
* GMG: Overview at beginning

/home/greuel/Singular/Singular/LIB/normal.lib
* GMG: fixing nonreduced case, extra comments

/home/greuel/Singular/Singular/LIB/presolve.lib
* GMG: proc elimlinearpart, input of unit ideal fixed

/home/greuel/Singular/Singular/LIB/primdec.lib
* GMG: cosmetics, help text modified

/home/greuel/Singular/Singular/LIB/random.lib
* GMG: cosmetics

/home/greuel/Singular/Singular/LIB/sing.lib
* GMG: Author names


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/normal.lib

    r3d276d r091424  
    33// algorithms for computing the normalization based on
    44// the criterion of Grauert/Remmert and ideas of De Jong & Vasconcelos
    5 // written by Gert-Martin Greuel and Gerhard Pfister
    65///////////////////////////////////////////////////////////////////////////////
    76
    8 version="$Id: normal.lib,v 1.17 1999-07-07 14:39:11 obachman Exp $";
     7version="$Id: normal.lib,v 1.18 1999-08-03 11:43:08 obachman Exp $";
    98info="
    10 LIBRARY: normal.lib     PROCEDURES FOR NORMALIZATION
     9LIBRARY:  normal.lib     PROCEDURES FOR NORMALIZATION
     10AUTHORS:  Gert-Martin Greuel, email: greuel@mathematik.uni-kl.de,
     11          Gerhard Pfister, email: pfister@mathematik.uni-kl.de
    1112
    1213PROCEDURES:
    … …  
    2122LIB "presolve.lib";
    2223LIB "inout.lib";
    23 
    2424///////////////////////////////////////////////////////////////////////////////
    2525static
    … …  
    178178   intvec rw,rw1;
    179179   list L;
    180 
    181180   y = printlevel-voice+2;  // y=printlevel (default: y=0)
    182181 def P = basering;
    … …  
    222221   if ( y>=1 )
    223222   {
    224      "// compute p*Hom(rad(J),rad(J)) = p*J:J, p a non-zerodivisor";
     223     "// compute p*Hom(J,J) = p*J:J, p a non-zerodivisor";
    225224     "//   p is equal to:"; "";
    226225     p;
    227226     "";
    228227   }
    229 
    230228   f  = quotient(p*J,J);
    231229   if ( y>=1 )
    232    { "// the module p*Hom(rad(J),rad(J)) = p*J:J, p a non-zerodivisor";
    233 
     230   { "// the module p*Hom(J,J) = p*J:J, p a non-zerodivisor";
    234231      "// p"; p;
    235232      "// f=p*J:J";f;
    … …  
    281278      if(y>=1)
    282279      {
    283          "//   R=Hom(rad(J),rad(J))";
     280         "//   R=Hom(J,J)";
    284281         "   ";
    285282         lastRing;
    … …  
    302299         endphi;
    303300         "   ";
    304          pause();
     301         pause;
    305302         newline;
    306303      }
    … …  
    310307   if(y>=1)
    311308   {
    312       "// R is not equal to Hom(rad(J),rad(J)), we have to try again";
     309      "// R is not equal to Hom(J,J), we have to try again";
    313310      pause();
    314311      newline;
    315312   }
    316 //---------- Hom(J,j) != R: create new ring and map form old ring -------------
     313//---------- Hom(J,J) != R: create new ring and map form old ring -------------
    317314// the ring newR1/SBid+syzf will be isomorphic to Hom(J,J) as R-module
    318315
    … …  
    361358   if(y>=1)
    362359   {
    363       "// the ring structure of Hom(rad(J),rad(J)) as R-algebra";
     360      "// the ring structure of Hom(J,J) as R-algebra";
    364361      " ";
    365362      "//   the linear relations";
    … …  
    465462         (which is sometimes more efficient)
    466463RETURN:  a list of rings (say nor), in each ring nor[i] are two ideals
    467          norid, normap such that the product of the nor[i]/norid is the
    468          normalization of basering/id and normap is the map from basering/id
    469          to nor[i]/norid
     464         norid, normap such that the direct sum of the rings nor[i]/norid is
     465         the normalization of basering/id; normap gives the normalization map
     466         from basering/id to nor[i]/norid (for each i)
    470467NOTE:    to use the i-th ring type: def R=nor[i]; setring R;
    471468         increasing printlevel displays more comments (default: printlevel=0)
    … …  
    492489
    493490   if(size(#)==0)
     491//--------------- the factorizing Buchberger algorithm is used ---------------
    494492   {
    495493      prim[1]=id;
    … …  
    555553      result = normalizationPrimes(prim[1],maxideal(1));
    556554      sr = string(size(result));
    557 
     555     
    558556      dbprint(y+1,"
    559557// 'normal' created a list of "+sr+" ring(s).
    … …  
    565563// normap the map from the original basering to R/norid");
    566564
    567       // kill endphi,endid;
    568565       return(result);
    569566   }
    570567   else
     568//------------- the factorizing Buchberger algorithm is not used -------------
    571569   {
    572570      if(#[1]==0)
    … …  
    583581         "// we have ",size(prim),"components";
    584582      }
    585       for(i=1;i<=size(prim);i++)
     583      for(i=1; i<=size(prim); i++)
    586584      {
    587585         if(y>=1)
    … …  
    626624
    627625      dbprint(y+1,"
    628 // 'normal' created a list of "+sr+" ring(s).
     626// 'normal' created a list of "+sr+" ring(s). 
    629627// To see the rings, type (if the name of your list is nor):
    630      show( nor);
     628     show( nor);                 
    631629// To access the 1-st ring and map (and similair for the others), type:
    632      def R = nor[1]; setring R;  norid; normap;
     630     def R = nor[1]; setring R;  norid; normap; 
    633631// R/norid is the 1-st ring of the normalization and
    634632// normap the map from the original basering to R/norid");
    … …  
    653651static
    654652proc normalizationPrimes(ideal i,ideal ihp, list #)
    655 "USAGE:   normalizationPrimes(i);  i prime ideal
     653"USAGE:   normalizationPrimes(i,ihp[,si]);  i prime ideal, ihp map
     654         (partial normalization), si SB of singular locus
    656655RETURN:  a list of one ring L=R, in  R are two ideals
    657656         S,M such that R/M is the normalization
    658657         S is a standardbasis of M
    659658NOTE:    to use the ring: def r=L[1];setring r;
    660          printlevel >=1: display comments (default: printlevel=0)
     659         printlevel >= voice+1: display comments (default: printlevel=0)
    661660EXAMPLE: example normalizationPrimes; shows an example
    662661"
    663662{
    664663   int y = printlevel-voice+2;  // y=printlevel (default: y=0)
    665 
     664 
    666665   if(y>=1)
    667666   {
    … …  
    695694         setring BAS;
    696695         return(result);
    697 
    698696   }
    699697
    … …  
    702700     "// SB-computation of the input ideal";
    703701   }
    704    list SM=mstd(i);
    705 
     702   list SM=mstd(i);                //here the work starts
     703   int dimSM =  dim(SM[1]);
     704  // Case: Get an ideal containing a unit
     705   if( dimSM == -1)
     706   {  "";
     707      "      // A unit ideal was found.";
     708      "      // Stop with partial result computed so far";"";
     709     
     710         MB=SM[2];
     711         intvec rw;
     712         list LL=substpart(MB,ihp,0,rw);
     713         def newR6=LL[1];
     714         setring newR6;
     715         ideal norid=endid;
     716         ideal normap=endphi;
     717         kill endid,endphi;
     718         export norid;
     719         export normap;
     720         result=newR6;
     721         setring BAS;
     722         return(result);
     723   }
     724   
    706725   if(y>=1)
    707726   {
    708727      "//   the dimension is:"; "";
    709       dim(SM[1]);"";
     728      dimSM;"";
    710729   }
    711730
    … …  
    860879        &&(size(#)==0))
    861880   {
    862 
     881/*
     882write (":a normal-fehler" ,
     883         "basering:",string(basering),"nvars:", nvars(basering),
     884       "dim(SM[1]):",dim(SM[1]),"ncols(jacob(SM[2]))",ncols(jacob(SM[2])),
     885       "SM:", SM);
     886 
     887     pause();
     888*/     
    863889      J=minor(jacob(SM[2]),nvars(basering)-dim(SM[1]));
    864890      //ti=timer;
    865       if(y>=1)
     891      if(y >=1 )
    866892      {
    867893         "// SB of singular locus will be computed";
    … …  
    10901116      return(tluser);
    10911117   }
     1118    // A component with singular locus the whole component found
     1119   if( Ann == 1)
     1120   {
     1121      "// Input appeared not to be a radical ideal!";
     1122      "// A (everywhere singular) component with ideal";
     1123      "// equal to its Jacobian ideal was found";
     1124      "// Procedure will stop with partial result computed so far";"";
     1125     
     1126         MB=SM[2];
     1127         intvec rw;
     1128         list LL=substpart(MB,ihp,0,rw);
     1129         def newR6=LL[1];
     1130         setring newR6;
     1131         ideal norid=endid;
     1132         ideal normap=endphi;
     1133         kill endid,endphi;
     1134         export norid;
     1135         export normap;
     1136         result=newR6;
     1137         setring BAS;
     1138         return(result);
     1139   }
    10921140   else
    10931141   {
    … …  
    11731221static
    11741222proc substpart(ideal endid, ideal endphi, int homo, intvec rw)
     1223
     1224"//Repeated application of elimpart to endid, until no variables can be
     1225//directy substituded. homo=1 if input is homogeneous, rw contains
     1226//original weights, endphi (partial) normalization map";
     1227
    11751228{
    11761229   def newRing=basering;
Note: See TracChangeset for help on using the changeset viewer.