Changeset 1eb7af in git


Ignore:
Timestamp:
Jun 22, 1999, 4:50:49 PM (24 years ago)
Author:
Mathias Schulze <mschulze@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
4ad2bb592a6ffe7f195320a5d4bec4f9ef0c57dd
Parents:
a5bf8808e70b84793a93e968ce4ab2cd1fb26fd9
Message:
*** empty log message ***


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/mondromy.lib

    ra5bf88 r1eb7af  
    11///////////////////////////////////////////////////////////////////////////////
    22
    3 version="$Id: mondromy.lib,v 1.1 1999-06-22 10:42:24 obachman Exp $";
     3version="$Id: mondromy.lib,v 1.2 1999-06-22 14:50:49 mschulze Exp $";
    44info="
    55LIBRARY: mondromy.lib  PROCEDURES TO COMPUTE THE MONODROMY OF A SINGULARITY
    … …  
    88 invunit(u,n);         series inverse of polynomial u up to order n
    99 detadj(U);            determinant and adjoint matrix of square matrix U
     10 jacoblift(f);         lifts f^kappa in jacob(f) with minimal kappa
    1011 monodromy(f[,opt]);   monodromy of isolated hypersurface singularity f
     12 H''basis(f);          basis of Brieskorn lattice H''
    1113";
    1214
    … …  
    6466  }
    6567}
     68
    6669///////////////////////////////////////////////////////////////////////////////
    6770
    … …  
    115118  if(size(V)>0)
    116119  {
    117     dbprint(printlevel-voice+2,"//computing codimension...");
    118120    dbprint(printlevel-voice+2,"//vector space dimension: "+string(codim));
    119     dbprint(printlevel-voice+2,"//number of generators: "+string(size(V)));
     121    dbprint(printlevel-voice+2,
     122      "//number of subspace generators: "+string(size(V)));
    120123    int t=timer;
    121124    codim=codim-ncols(interred(module(V[1..size(V)])));
    122     dbprint(printlevel-voice+2,"//...codimension computed ["+string(timer-t)+
    123       " secs]");
     125    dbprint(printlevel-voice+2,"//codimension: "+string(codim));
    124126  }
    125127  return(codim);
    … …  
    132134  if(size(V)>0)
    133135  {
    134     dbprint(printlevel-voice+2,"//computing quotient vector space...");
    135136    dbprint(printlevel-voice+2,"//vector space dimension: "+string(nrows(Q)));
    136     dbprint(printlevel-voice+2,"//number of generators: "+string(size(V)));
     137    dbprint(printlevel-voice+2,
     138      "//number of subspace generators: "+string(size(V)));
    137139    int t=timer;
    138140    Q=interred(reduce(std(Q),std(module(V[1..size(V)]))));
    139     dbprint(printlevel-voice+2,"//...quotient vector space computed ["
    140       +string(timer-t)+" secs]");
    141141  }
    142142  return(list(Q[1..size(Q)]));
    … …  
    145145
    146146proc invunit(poly u,int n)
    147 "USAGE:   invunit(u,n); u polynomial, n integer
     147"USAGE:   invunit(u,n); u poly, n int
    148148ASSUME:  The polynomial u is a series unit.
    149149RETURN:  The procedure returns the series inverse of u up to order n
    … …  
    243243///////////////////////////////////////////////////////////////////////////////
    244244
    245 static proc getkappaxiu(poly f)
     245proc jacoblift(poly f)
     246"USAGE:   jacoblift(f); f poly
     247ASSUME:  The polynomial f in a series ring (local ordering) defines
     248         an isolated hypersurface singularity.
     249RETURN:  The procedure returns a list with entries kappa, xi, u of type
     250         int, vector, poly such that kappa is minimal with f^kappa in jacob(f),
     251         u is a unit, and u*f^kappa=(matrix(jacob(f))*xi)[1,1].
     252DISPLAY: printlevel>=1; shows comments.
     253EXAMPLE: example jacoblift; shows an example.
     254"
    246255{
    247256  dbprint(printlevel-voice+2,"//computing kappa...");
    … …  
    270279  dbprint(printlevel-voice+2,"//...u computed ["+string(timer-t)+" secs]");
    271280
    272   return(kappa,xi,u);
     281  return(list(kappa,xi,u));
     282}
     283example
     284{ "EXAMPLE:"; echo=2;
     285  ring R=0,(x,y),ds;
     286  poly f=x2y2+x6+y6;
     287  jacoblift(f);
    273288}
    274289///////////////////////////////////////////////////////////////////////////////
    … …  
    340355
    341356  deltaN=1;
     357  dbprint(printlevel-voice+2,"//computing codimension of");
     358  dbprint(printlevel-voice+2,"//df^dOmega^(n-1)+f^K*Omega^(n+1) in "
     359    +"Omega^(n+1) mod m^N*Omega^(n+1)...");
     360  int t=timer;
    342361  while(codimV(V1+V2,N)<K*mu)
    343362  {
     363    dbprint(printlevel-voice+2,"//...codimension computed ["+string(timer-t)
     364      +" secs]");
     365
    344366    deltaP1=getdeltaP1(f,K,N,deltaN);
    345367    V1=pcvladdl(V1,pcvp2cv(P1,N,N+deltaN))+pcvp2cv(deltaP1,0,N+deltaN);
    … …  
    354376    N=N+deltaN;
    355377    dbprint(printlevel-voice+2,"//N="+string(N));
    356   }
     378
     379    dbprint(printlevel-voice+2,"//computing codimension of");
     380    dbprint(printlevel-voice+2,"//df^dOmega^(n-1)+f^K*Omega^(n+1) in "
     381      +"Omega^(n+1) mod m^N*Omega^(n+1)...");
     382    t=timer;
     383  }
     384  dbprint(printlevel-voice+2,"//...codimension computed ["+string(timer-t)
     385    +" secs]");
    357386
    358387  return(K,N,P1,P2,Pe,V1,V2,Ve);
    … …  
    397426
    398427  dbprint(printlevel-voice+2,
    399     "//lifting nabla(e) to vector space basis of H''/t^KH''...");
     428    "//lifting nabla(e) to C-basis of H''/t^KH''...");
    400429  list V=Ve+V1+V2;
    401430  module W=module(V[1..size(V)]);
    … …  
    407436    +" secs]");
    408437
    409   dbprint(printlevel-voice+2,"//computing lift of nabla(e) to e...");
     438  dbprint(printlevel-voice+2,"//computing e-lift of nabla(e)...");
    410439  t=timer;
    411440  int i1,i2,j,k;
    … …  
    421450    }
    422451  }
    423   dbprint(printlevel-voice+2,"//...lift of nabla(e) to e computed ["
     452  dbprint(printlevel-voice+2,"//...e-lift of nabla(e) computed ["
    424453    +string(timer-t)+" secs]");
    425454
    … …  
    542571  pcvinit();
    543572
    544   dbprint(printlevel-voice+2,"//computing kappa, xi and u...");
    545   def kappa,xi,u=getkappaxiu(f);
     573  dbprint(printlevel-voice+2,"//computing kappa, xi and u with "+
     574    "u*f^kappa=(matrix(jacob(f))*xi)[1,1]...");
     575  list jl=jacoblift(f);
     576  def kappa,xi,u=jl[1..3];
    546577  dbprint(printlevel-voice+2,"//...kappa, xi and u computed");
    547578  dbprint(printlevel-voice+2,"//kappa="+string(kappa));
    548579  if(kappa==1)
    549580  {
    550     dbprint(printlevel-voice+2,"//singularity quasihomogeneous");
     581    dbprint(printlevel-voice+2,
     582      "//f quasihomogenous with respect to suitable coordinates");
    551583  }
    552584  else
    553585  {
    554     dbprint(printlevel-voice+2,"//singularity not quasihomogeneous");
     586    dbprint(printlevel-voice+2,
     587      "//f not quasihomogenous for any choice of coordinates");
    555588  }
    556589  dbprint(printlevel-voice+2,"//xi=");
    … …  
    565598  dbprint(printlevel-voice+2,"//...K and N increased");
    566599
    567   dbprint(printlevel-voice+2,
    568     "//computing basis e of Brieskorn lattice H''...");
     600  dbprint(printlevel-voice+2,"//computing C{f}-basis e of Brieskorn lattice "
     601    +"H''=Omega^(n+1)/df^dOmega^(n-1)...");
     602  int t=timer;
    569603  e=pcvcv2p(quotV(V1+V2,N),0,N);
    570   dbprint(printlevel-voice+2,"//...e computed");
     604  dbprint(printlevel-voice+2,"//...e computed ["+string(timer-t)+" secs]");
    571605
    572606  dbprint(printlevel-voice+2,"//e=");
    … …  
    593627    int i;
    594628    dbprint(printlevel-voice+2,"//comparing with previous lattice...");
    595     int t=timer;
     629    t=timer;
    596630    for(i=mu-1;i>=1&&size(reduce(U,std(prevU)))>0;i--)
    597631    {
    … …  
    627661    {
    628662      dbprint(printlevel-voice+2,
    629         "//computing basis of t*nabla-stable lattice...");
     663        "//computing C{f}-basis of t*nabla-stable lattice...");
    630664      t=timer;
    631665      U=minbase(U);
    632666      dbprint(printlevel-voice+2,
    633         "//...basis of t*nabla-stable lattice computed ["+string(timer-t)
     667        "//...C{f}-basis of t*nabla-stable lattice computed ["+string(timer-t)
    634668        +" secs]");
    635669    }
    … …  
    740774{
    741775  dbprint(printlevel-voice+2,"//computing basis e of Milnor algebra...");
     776  int t=timer;
    742777  ideal e=kbase(std(jacob(f)));
    743   dbprint(printlevel-voice+2,"//...e computed");
     778  dbprint(printlevel-voice+2,"//...e computed ["+string(timer-t)+" secs]");
    744779
    745780  dbprint(printlevel-voice+2,
    … …  
    762797
    763798proc monodromy(poly f, list #)
    764 "USAGE:   monodromy(f[,opt]); f polynomial, opt integer
     799"USAGE:   monodromy(f[,opt]); f poly, opt int
    765800ASSUME:  The polynomial f in a series ring (local ordering) defines
    766801         an isolated hypersurface singularity.
    767 RETURN:  The procedure returns a residue matrix of the meromorphic Gauss-Manin
    768          connection of the singularity defined by f or an empty matrix
    769          if the assumptions are not fulfilled.
    770          If opt=0 (default), the matrix exp(2*pi*i*monodromy(f)) is a
    771          monodromy matrix of the singularity defined by f, else the
    772          characteristic polynomial of the matrix exp(2*pi*i*monodromy(f))
    773          is the characteristic polynomial of the monodromy of the singularity
    774          defined by f.
    775 DISPLAY: printlevel>=1; shows comments.
    776 EXAMPLE: example monodromy; shows an example.
     802RETURN:  The procedure returns a residue matrix M of the meromorphic
     803         Gauss-Manin connection of the singularity defined by f
     804         or an empty matrix if the assumptions are not fulfilled.
     805         If opt=0 (default), exp(2*pi*i*M) is a monodromy matrix of f,
     806         else, only the characteristic polynomial of exp(2*pi*i*M) coincides
     807         with the characteristic polynomial of the monodromy of f.
    777808THEORY:  The procedure uses an algorithm by Brieskorn (See E. Brieskorn,
    778          Die Monodromie der isolierten Singularitaeten von Hyperflaechen,
    779809         manuscipta math. 2 (1970), 103-161) to compute a connection matrix of
    780810         the meromorphic Gauss-Manin connection up to arbitrarily high order,
    781811         and an algorithm of Gerard and Levelt (See R. Gerard, A.H.M. Levelt,
    782          Invariants mesurant l'irregularite en un point singulier des systeme
    783          d'equations differentielles lineaires, Ann. Inst. Fourier,
    784          Grenoble 23,1 (1973), pp. 157-195) to transform it to a simple pole.
    785          For a detailed description of the algorithm see M. Schulze,
    786          Computation of the Monodromy of an Isolated Hypersurface Singularity.
     812         Ann. Inst. Fourier, Grenoble 23,1 (1973), pp. 157-195) to transform
     813         it to a simple pole.
     814DISPLAY: printlevel>=1; shows comments.
     815EXAMPLE: example monodromy; shows an example.
    787816"
    788817{
    … …  
    802831  }
    803832
     833  dbprint(printlevel-voice+2,"//basering="+string(basering));
     834
    804835  int i;
    805836  for(i=nvars(basering);i>=1;i--)
    … …  
    811842  }
    812843
    813   dbprint(printlevel-voice+2,"//basering="+string(basering));
    814 
    815844  if(i<0)
    816845  {
    817846    print("//no series ring (local ordering)");
     847
     848    matrix M[1][0];
     849    return(M);
    818850  }
    819851  else
    … …  
    822854
    823855    dbprint(printlevel-voice+2,"//computing milnor number mu of f...");
     856    int t=timer;
    824857    int mu=milnor(f);
    825     dbprint(printlevel-voice+2,"//...mu computed");
     858    dbprint(printlevel-voice+2,"//...mu computed ["+string(timer-t)+" secs]");
    826859
    827860    dbprint(printlevel-voice+2,"//mu="+string(mu));
    … …  
    851884      if(w==0)
    852885      {
    853         dbprint(printlevel-voice+2,"//polynomial not quasihomogeneous");
     886        dbprint(printlevel-voice+2,
     887          "//f not quasihomogeneous with respect to given coordinates");
    854888        return(nonqhmonodromy(f,mu,opt));
    855889      }
    856890      else
    857891      {
    858         dbprint(printlevel-voice+2,"//polynomial quasihomogeneous");
     892        dbprint(printlevel-voice+2,
     893          "//f quasihomogeneous with respect to given coordinates");
    859894        return(qhmonodromy(f,w));
    860895      }
    … …  
    870905}
    871906///////////////////////////////////////////////////////////////////////////////
     907
     908proc H''basis(poly f)
     909"USAGE:   H''basis(f); f poly
     910ASSUME:  The polynomial f in a series ring (local ordering) defines
     911         an isolated hypersurface singularity.
     912RETURN:  The procedure returns a list of representatives of a C{f}-basis of the
     913         Brieskorn lattice H''=Omega^(n+1)/df^dOmega^(n-1).
     914THEORY:  H'' is a free C{f}-module of rank milnor(f).
     915DISPLAY: printlevel>=1; shows comments.
     916EXAMPLE: example H''basis; shows an example.
     917"
     918{
     919  pcvinit();
     920
     921  dbprint(printlevel-voice+2,"//basering="+string(basering));
     922
     923  int i;
     924  for(i=nvars(basering);i>=1;i--)
     925  {
     926    if(1<var(i))
     927    {
     928      i=-1;
     929    }
     930  }
     931
     932  if(i<0)
     933  {
     934    print("//no series ring (local ordering)");
     935
     936    return(list());
     937  }
     938  else
     939  {
     940    dbprint(printlevel-voice+2,"//f="+string(f));
     941
     942    dbprint(printlevel-voice+2,"//computing milnor number mu of f...");
     943    int t=timer;
     944    int mu=milnor(f);
     945    dbprint(printlevel-voice+2,"//...mu computed ["+string(timer-t)+" secs]");
     946
     947    dbprint(printlevel-voice+2,"//mu="+string(mu));
     948
     949    if(mu<=0)
     950    {
     951      if(mu==0)
     952      {
     953        print("//no singularity");
     954      }
     955      else
     956      {
     957        print("//non isolated singularity");
     958      }
     959
     960      return(list());
     961    }
     962    else
     963    {
     964      dbprint(printlevel-voice+2,"//computing kappa, xi and u with "+
     965        "u*f^kappa=(matrix(jacob(f))*xi)[1,1]...");
     966      list jl=jacoblift(f);
     967      def kappa,xi,u=jl[1..3];
     968      dbprint(printlevel-voice+2,"//...kappa, xi and u computed");
     969      dbprint(printlevel-voice+2,"//kappa="+string(kappa));
     970      if(kappa==1)
     971      {
     972        dbprint(printlevel-voice+2,
     973          "//f quasihomogenous with respect to suitable coordinates");
     974      }
     975      else
     976      {
     977        dbprint(printlevel-voice+2,
     978          "//f not quasihomogenous for any choice of coordinates");
     979      }
     980      dbprint(printlevel-voice+2,"//xi=");
     981      dbprint(printlevel-voice+2,xi);
     982      dbprint(printlevel-voice+2,"//u="+string(u));
     983
     984      int K,N,prevN;
     985      list e,P1,P2,Pe,V1,V2,Ve,Vnablae;
     986
     987      dbprint(printlevel-voice+2,"//increasing K and N...");
     988      K,N,P1,P2,Pe,V1,V2,Ve=incK(f,mu,K,1,N,e,P1,P2,Pe,V1,V2,Ve);
     989      dbprint(printlevel-voice+2,"//...K and N increased");
     990
     991      dbprint(printlevel-voice+2,
     992        "//computing C{f}-basis e of Brieskorn lattice "
     993        +"H''=Omega^(n+1)/df^dOmega^(n-1)...");
     994      t=timer;
     995      e=pcvcv2p(quotV(V1+V2,N),0,N);
     996      dbprint(printlevel-voice+2,"//...e computed ["+string(timer-t)+" secs]");
     997
     998      dbprint(printlevel-voice+2,"//e=");
     999      dbprint(printlevel-voice+2,e);
     1000
     1001      return(e);
     1002    }
     1003  }
     1004}
     1005example
     1006{ "EXAMPLE:"; echo=2;
     1007  ring R=0,(x,y),ds;
     1008  poly f=x2y2+x6+y6;
     1009  H''basis(f);
     1010}
     1011///////////////////////////////////////////////////////////////////////////////
Note: See TracChangeset for help on using the changeset viewer.