Changeset 275721f in git

Timestamp:

Nov 20, 2001, 2:00:41 PM (22 years ago)

Author:

Mathias Schulze <mschulze@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

20f6fdc67e5c7c3be158b51d3369c84b45b48cc0

Parents:

1f1e936f1d8cfea771388e62a2423fe8f47f7d2e

Message:

*** empty log message ***


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

Location:

Singular/LIB

Files:

• gaussman.lib (modified) (38 diffs)
• linalg.lib (modified) (14 diffs)

Singular/LIB/gaussman.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: gaussman.lib,v 1.57 2001-11-07 09:55:50 mschulze Exp $";
+version="$Id: gaussman.lib,v 1.58 2001-11-20 13:00:34 mschulze Exp $";
 category="Singularities";
 
 info="
-LIBRARY:  gaussman.lib  Gauss-Manin Connection of a Singularity
+LIBRARY:  gaussman.lib  Algorithmic Gauss-Manin Connection
 
 AUTHOR:   Mathias Schulze, email: mschulze@mathematik.uni-kl.de
 
-OVERVIEW: A library to compute invariants related to the Gauss-Manin connection
-          of a an isolated hypersurface singularity
+OVERVIEW: A library to compute Hodge-theoretic invariants 
+          of isolated hypersurface singularities
 
 PROCEDURES:
- gmsring(t,s);              Brieskorn lattice in Gauss-Manin system of t
- gmsnf(p,K[,Kmax]);         Gauss-Manin system normal form
- gmscoeffs(p,K[,Kmax]);     Gauss-Manin system basis representation
+ gmsring(t,s);              Gauss-Manin system of t with variable s
+ gmsnf(p,K[,Kmax]);         Gauss-Manin system normal form of p
+ gmscoeffs(p,K[,Kmax]);     Gauss-Manin system basis representation of p
  monodromy(t);              Jordan data of monodromy of t
- spectrum(t);               spectrum of t
+ spectrum(t);               singularity spectrum of t
  sppairs(t);                spectral pairs of t
- sppnf(a,w[,m][,v|V]);      normalize spectral pairs
- vfilt(t);                  V-filtration of t on H''/H'
- vwfilt(t);                 weight refined V-filtration of t on H''/H'
- saito(t);                  matrix A0+A1*s of t on H''
+ sppnf(a,w[,m][,V]);        spectral pairs normal form of (a,w,m,V)
+ vfilt(t);                  V-filtration of t on Brieskorn lattice H''
+ vwfilt(t);                 weighted V-filtration of t on Brieskorn lattice H''
+ tmatrix(t);                t-matrix on Brieskorn lattice H''
  endvfilt(V);               endomorphism V-filtration on Jacobian algebra
  spprint(sp);               print spectrum sp
@@ -27 +27 @@
  spadd(sp1,sp2);            sum of spectra sp1 and sp2
  spsub(sp1,sp2);            difference of spectra sp1 and sp2
- spmul(sp,k);               product of spectrum sp and integer k
- spmul(sp,k);               linear combination of spectra sp with coeffs k
- spissemicont(sp[,opt]);    test spectrum sp for semicontinuity
- spsemicont(sp0,sp[,opt]);  semicontinuity of spectra sp0 and sp
+ spmul(sp0,k);              linear combination of spectra sp
+ spissemicont(sp[,opt]);    semicontinuity test of spectrum sp
+ spsemicont(sp0,sp[,opt]);  semicontinuous combinations of spectra sp0 in sp
  spmilnor(sp);              milnor number of spectrum sp
  spgeomgenus(sp);           geometrical genus of spectrum sp
@@ -108 +107 @@
 
 proc gmsring(poly t,string s)
-"USAGE:    gmsring(t,s); poly t, string s;
-ASSUME:   basering with characteristic 0 and local degree ordering,
-          t with isolated citical point 0
+"USAGE:    gmsring(t,s); poly t, string s
+ASSUME:   characteristic 0; local degree ordering;
+          isolated citical point 0 of t
 RETURN:
 @format
-ring G: C{{s}}*basering,
-  poly gmspoly: image of t
-  ideal gmsjacob: image of Jacobian ideal
-  ideal gmsstd: image of standard basis of Jacobian ideal
-  matrix gmsmatrix: matrix(gmsjacob)*gmsmatrix=matrix(gmsstd)
-  ideal gmsbasis: image of monomial vector space basis of Jacobian algebra
-  int gmsmaxweight: maximal weight of variables of basering
+ring G;  Gauss-Manin system of t with variable s
+  poly gmspoly=t;
+  ideal gmsjacob;  Jacobian ideal of t
+  ideal gmsstd;  standard basis of Jacobian ideal
+  matrix gmsmatrix;  matrix(gmsjacob)*gmsmatrix=matrix(gmsstd)
+  ideal gmsbasis;  monomial vector space basis of Jacobian algebra
+  int gmsmaxweight;  maximal weight of variables
 @end format
-NOTE:     do not modify gms variables if you want to use gms procedures
 KEYWORDS: singularities; Gauss-Manin connection; Brieskorn lattice
-EXAMPLE:  example gms; shows examples
+EXAMPLE:  example gmsring; shows examples
 "
 {
@@ -214 +212 @@
 
 proc gmsnf(ideal p,int K,list #)
-"USAGE:    gmsnf(p,K[,Kmax]); poly p, int K[, int Kmax];
-ASSUME:   basering constructed by gmsring, K<=Kmax
+"USAGE:    gmsnf(p,K[,Kmax]); poly p, int K, int Kmax
+ASSUME:   basering returned by gmsring; K<=Kmax
 RETURN:
 @format
-list l:
-  ideal l[1]: projection of p to H''=C{{s}}*gmsbasis mod s^{K+1}
-  ideal l[2]: p=l[1]+l[2] mod s^(Kmax+1)
+list nf; 
+  ideal nf[1];  projection of p to gmsbasis mod s^(K+1)
+  ideal nf[2];  p=nf[1]+nf[2] mod s^(Kmax+1)
 @end format
-NOTE:     by setting p=l[2] the computation can be continued up to order
-          at most Kmax, by default Kmax=infinity
 KEYWORDS: singularities; Gauss-Manin connection; Brieskorn lattice
 EXAMPLE:  example gmsnf; shows examples
@@ -317 +313 @@
 
 proc gmscoeffs(ideal p,int K,list #)
-"USAGE:    gmscoeffs(p,K[,Kmax]); poly p, int K[, int Kmax];
+"USAGE:    gmscoeffs(p,K[,Kmax]); poly p, int K, int Kmax
 ASSUME:   basering constructed by gmsring, K<=Kmax
 RETURN:
 @format
-list l:
-  matrix l[1]: projection of p to H''=C{{s}}*gmsbasis=C{{s}}^mu mod s^(K+1)
-  ideal l[2]: p=matrix(gmsbasis)*l[1]+l[2] mod s^(Kmax+1)
+list l; 
+  matrix l[1];  gmsbasis representation of p mod s^(K+1)
+  ideal l[2];  p=matrix(gmsbasis)*l[1]+l[2] mod s^(Kmax+1)
 @end format
 NOTE:     by setting p=l[2] the computation can be continued up to order 
@@ -386 +382 @@
 ///////////////////////////////////////////////////////////////////////////////
 
+static proc liftbound(module U,module H,int k,int K)
+{
+  def R=basering;
+  ring S=0,s,ds;
+  module U=imap(R,U);
+  module H=imap(R,H);
+  degBound=k+K+1;
+  H=jet(lift(U,H),K);
+  degBound=0;
+  setring(R);
+  return(imap(S,H));
+}
+///////////////////////////////////////////////////////////////////////////////
+
 static proc saturate(int K0)
 {
@@ -416 +426 @@
 
   dbprint(printlevel-voice+2,"// transform H'' to saturation of H''");
-  l=division(H,freemodule(mu)*s^k);
-  H0=l[1];
+//  l=division(H,freemodule(mu)*s^k);
+//  H0=l[1];
+  H0=liftbound(H,freemodule(mu)*s^k,k,k);
 
   return(A0,r,H,H0,k);
@@ -423 +434 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-static proc tmatrix(matrix A0,ideal r,module H,int k0,int K,int K0)
+static proc tmat(matrix A0,ideal r,module H,int k0,int K,int K0)
 {
   dbprint(printlevel-voice+2,"// compute matrix A of t");
@@ -433 +444 @@
 
   dbprint(printlevel-voice+2,"// transform A to saturation of H''");
-  l=division(H*s,A0*H+s^2*diff(matrix(H),s));
-  matrix A=jet(l[1],l[2],K);
+//  l=division(H*s,A0*H+s^2*diff(matrix(H),s));
+//  matrix A=jet(l[1],l[2],K);
+  matrix A=liftbound(H*s,A0*H+s^2*diff(matrix(H),s),k0+1,K);
 
   return(A,A0,r);
@@ -440 +452 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-static proc eigenvals(matrix A0,ideal r,module H,int k0,int K0)
+static proc eigvals(matrix A0,ideal r,module H,int k0,int K0)
 {
   dbprint(printlevel-voice+2,
     "// compute eigenvalues e with multiplicities m of A");
   matrix A;
-  A,A0,r=tmatrix(A0,r,H,k0,0,K0);
-  list l=eigenvalues(A);
+  A,A0,r=tmat(A0,r,H,k0,0,K0);
+  list l=eigenvals(A);
   def e,m=l[1..2];
   dbprint(printlevel-voice+2,"// e="+string(e));
@@ -455 +467 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-static proc transform(matrix A,matrix A0,ideal r,module H,module H0,ideal e,intvec m,int k0,int k1,int K,int K0)
+static proc transf(matrix A,matrix A0,ideal r,module H,module H0,ideal e,intvec m,int k0,int k1,int K,int K0)
 {
   int mu=ncols(gmsbasis);
@@ -463 +475 @@
   dbprint(printlevel-voice+2,"// e0="+string(e0));
   dbprint(printlevel-voice+2,"// e1="+string(e1));
-  A,A0,r=tmatrix(A0,r,H,k0,K+k1,K0+k1);
+  A,A0,r=tmat(A0,r,H,k0,K+k1,K0+k1);
   module U0=s^k0*freemodule(mu);
 
@@ -541 +553 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc monodromy(poly t,list #)
+proc monodromy(poly t)
 "USAGE:    monodromy(t); poly t
-ASSUME:   basering with characteristic 0 and local degree ordering,
-          t with isolated citical point 0
-RETURN:   list l: Jordan data jordan(M) of a monodromy matrix exp(-2*pi*i*M)
-SEE ALSO: mondromy_lib
+ASSUME:   characteristic 0; local degree ordering;
+          isolated citical point 0 of t
+RETURN:   list l;  Jordan data jordan(M) of monodromy matrix exp(-2*pi*i*M)
+SEE ALSO: mondromy_lib, linalg.lib
 KEYWORDS: singularities; Gauss-Manin connection; Brieskorn lattice; monodromy
 EXAMPLE:  example monodromy; shows examples
@@ -563 +575 @@
 
   def A0,r,H,H0,k0=saturate(n);
-  e,m,A0,r,k1=eigenvals(A0,r,H,k0,n);
-  A,A0,r,H0,U0,e,m=transform(A,A0,r,H,H0,e,m,k0,k1,0,0);
+  e,m,A0,r,k1=eigvals(A0,r,H,k0,n);
+  A,A0,r,H0,U0,e,m=transf(A,A0,r,H,H0,e,m,k0,k1,0,0);
 
   setring(R);
@@ -579 +591 @@
 proc spectrum(poly t)
 "USAGE:    spectrum(t); poly t
-ASSUME:   basering with characteristic 0 and local degree ordering,
-          t with isolated citical point 0
+ASSUME:   characteristic 0; local degree ordering;
+          isolated citical point 0 of t
 RETURN:
 @format
-list sp: spectrum of t
-  ideal sp[1]: V-filtration indices in increasing order
-  intvec sp[2]: weight filtration indices in decreasing order
-  intvec sp[3]:
-    int sp[3][i]: multiplicity of spectral number sp[1][i]
+list sp;  singularity spectrum of t
+  ideal sp[1];
+    number sp[1][i];  i-th spectral number
+  intvec sp[2];
+    int sp[2][i];  multiplicity of i-th spectral number
 @end format
 SEE ALSO: spectrum_lib
@@ -608 +620 @@
 proc sppairs(poly t)
 "USAGE:    sppairs(t); poly t
-ASSUME:   basering with characteristic 0 and local degree ordering,
-          t with isolated citical point 0
+ASSUME:   characteristic 0; local degree ordering;
+          isolated citical point 0 of t
 RETURN:
 @format
-list spp: spectrum of t
-  ideal spp[1],intvec spp[2]: spectral pairs in in-/decreasing lex. order
-  intvec spp[3]:
-    int spp[3][i]: multiplicity of spectral pair (spp[1][i],spp[2][i])
+list spp;  spectral pairs of t
+  ideal spp[1];
+    number spp[1][i];  V-filtration index of i-th spectral pair
+  intvec spp[2];
+    int spp[2][i];  weight filtration index of i-th spectral pair
+  intvec spp[3]; 
+    int spp[3][i];  multiplicity of i-th spectral pair
 @end format
 SEE ALSO: spectrum_lib
@@ -636 +651 @@
 
 proc sppnf(ideal a,intvec w,list #)
-"USAGE:    sppnf(a,w[,m][,v|V]); ideal a, intvec w, intvec m, module v, list V
+"USAGE:    sppnf(a,w[,m][,V]); ideal a, intvec w, intvec m, list V
+ASSUME:   ncols(e)=size(w)=size(m)=size(V); module V[i]
 RETURN:
 @format
-list spp: normalized spectral pairs (a,w,m[,V])
-  ideal spp[1]: numbers in a in increasing order
-  intvec spp[2]: integers in w in decreasing order
-  intvec spp[3]:
-    int spp[3][i]: multiplicity of pair (spp[1][i],spp[2][i]) in (a,w)
-  list spp[4]:
-    module spp[4][i]: module associated to pair (spp[1][i],spp[2][i])
+list spp;  spectral pairs normal form of (a,w,m,V)
+  ideal spp[1];
+    number spp[1][i];  V-filtration index of i-th spectral pair
+  intvec spp[2];
+    int spp[2][i];  weight filtration index of i-th spectral pair
+  intvec spp[3]; 
+    int spp[3][i];  multiplicity of i-th spectral pair
+  list spp[4]; 
+    module spp[4][i];  vector space of i-th spectral pair
 @end format
+SEE ALSO: spectrum_lib
+KEYWORDS: singularities; Gauss-Manin connection; Brieskorn lattice;
+          mixed Hodge structure; V-filtration; weight filtration;
+          spectrum; spectral pairs
 EXAMPLE:  example sppnorm; shows examples
 "
@@ -770 +792 @@
 proc vfilt(poly t)
 "USAGE:    vfilt(t); poly t
-ASSUME:   basering with characteristic 0 and local degree ordering,
-          t with isolated citical point 0
-RETURN:t
+ASSUME:   characteristic 0; local degree ordering;
+          isolated citical point 0 of t
+RETURN:
 @format
-list v: V-filtration on H''/H'
-  ideal v[1]: spectral numbers in increasing order
-  intvec v[2]:
-    int v[2][i]: multiplicity of spectral number v[1][i]
-  list v[4]:
-    module v[4][i]: vector space basis of v[1][i]-th graded part 
-                    in terms of v[4]
-  ideal v[4]: monomial vector space basis of H''/H'
-  ideal v[5]: standard basis of Jacobian ideal
+list v;  V-filtration on H''/s*H''
+  ideal v[1];
+    number v[1][i];  V-filtration index of i-th spectral pair
+  intvec v[2]; 
+    int v[2][i];  multiplicity of i-th spectral pair
+  list v[3]; 
+    module v[3][i];  vector space of i-th spectral pair in terms of v[4]
+  ideal v[4];  monomial vector space basis of H''/s*H''
+  ideal v[5];  standard basis of Jacobian ideal
 @end format
 SEE ALSO: spectrum_lib
@@ -803 +825 @@
 proc vwfilt(poly t)
 "USAGE:    vwfilt(t); poly t
-ASSUME:   basering with characteristic 0 and local degree ordering,
-          t with isolated citical point 0
+ASSUME:   characteristic 0; local degree ordering;
+          isolated citical point 0 of t
 RETURN:
 @format
-list vw: weight refined V-filtration on H''/H'
-  ideal vw[1]: spectral numbers in increasing order
-  intvec vw[2]: weights in decreasing order
-  intvec vw[3]:
-    int vw[3][i]: multiplicity of spectral pair (vw[1][i],vw[2][i])
-  list vw[4]:
-    module vw[4][i]: vector space basis of (vw[1][i],vw[2][i])-th graded part 
-                     in terms of vw[5]
-  ideal vw[5]: monomial vector space basis of H''/H'
-  ideal vw[6]: standard basis of Jacobian ideal
+list vw;  weighted V-filtration on H''/s*H''
+  ideal vw[1];
+    number vw[1][i];  V-filtration index of i-th spectral pair
+  intvec vw[2];
+    int vw[2][i];  weight filtration index of i-th spectral pair
+  intvec vw[3]; 
+    int vw[3][i];  multiplicity of i-th spectral pair
+  list vw[4]; 
+    module vw[4][i];  vector space of i-th spectral pair
+                      in terms of vw[5]
+  ideal vw[5];  monomial vector space basis of H''/s*H''
+  ideal vw[6];  standard basis of Jacobian ideal
 @end format
 SEE ALSO: spectrum_lib
@@ -838 +862 @@
 
   def A0,r,H,H0,k0=saturate(n);
-  e,m,A0,r,k1=eigenvals(A0,r,H,k0,n);
-  A,A0,r,H0,U0,e,m=transform(A,A0,r,H,H0,e,m,k0,k1,0,0);
+  e,m,A0,r,k1=eigvals(A0,r,H,k0,n);
+  A,A0,r,H0,U0,e,m=transf(A,A0,r,H,H0,e,m,k0,k1,0,0);
 
   dbprint(printlevel-voice+2,"// compute weight filtration basis");
@@ -895 +919 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc saito(poly t,list #)
-"USAGE:    saito(t); poly t
-ASSUME:   basering with characteristic 0 and local degree ordering,
-          t with isolated citical point 0
-RETURN:   list A: matrix A[1]+A[2]*s of t on H''
+static proc commutator(matrix A)
+{
+  int n=ncols(A);
+  int i,j,k;
+  matrix C[n^2][n^2];
+  for(i=0;i<n;i++)
+  {
+    for(j=0;j<n;j++)
+    {
+      for(k=0;k<n;k++)
+      {
+        C[i*n+j+1,k*n+j+1]=C[i*n+j+1,k*n+j+1]+A[i+1,k+1];
+        C[i*n+j+1,i*n+k+1]=C[i*n+j+1,i*n+k+1]-A[k+1,j+1];
+      }
+    }
+  }
+  return(C);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+proc tmatrix(poly t,list #)
+"USAGE:    tmatrix(t); poly t
+ASSUME:   characteristic 0; local degree ordering;
+          isolated citical point 0 of t
+RETURN:   list A;  t-matrix A[1]+s*A[2] on H''
 KEYWORDS: singularities; Gauss-Manin connection; Brieskorn lattice;
           mixed Hodge structure; opposite Hodge filtration; V-filtration;
-EXAMPLE:  example tmat; shows examples
+EXAMPLE:  example tmatrix; shows examples
 "
 {
@@ -918 +963 @@
 
   def A0,r,H,H0,k0=saturate(2*n+mu-1);
-  e,m,A0,r,k1=eigenvals(A0,r,H,k0,n);
-  A,A0,r,H0,U0,e,m=transform(A,A0,r,H,H0,e,m,k0,k1,k0+k1,k0+k1);
+  e,m,A0,r,k1=eigvals(A0,r,H,k0,n);
+  A,A0,r,H0,U0,e,m=transf(A,A0,r,H,H0,e,m,k0,k1,k0+k1,k0+k1);
 
   dbprint(printlevel-voice+2,"// transform to Jordan basis");
@@ -947 +992 @@
   dbprint(printlevel-voice+2,"// transform to V-splitting basis");
   A=jet(A,0);
-  H=jet(division(U,H)[1],k0+k1);
-  H=std(H);
+//  H=std(jet(division(U,H)[1],k0+k1));
+  H=std(liftbound(U,H,0,k0+k1));
 
   dbprint(printlevel-voice+2,"// compute V-leading terms of H''");
@@ -995 +1040 @@
     }
     F0=intersect(C,H0);
+
     F=list();
     j=0;
@@ -1053 +1099 @@
   degBound=k0+k1+1;
   option("redSB");
+
   H=std(H);
+
   degBound=0;
   H=simplify(jet(H,k0+k1),1);
@@ -1060 +1108 @@
 
   dbprint(printlevel-voice+2,"// compute matrix A0+sA1 of t");
-  list l=division(H,s*A*H+s^2*diff(matrix(H),s));
-  A=jet(l[1],l[2],k0+k1+1);
+//  list l=division(H,s*A*H+s^2*diff(matrix(H),s));
+//  A=jet(l[1],l[2],k0+k1+1);
+  A=liftbound(H,s*A*H+s^2*diff(matrix(H),s),k0+k1,1);
   A0=jet(A,0);
   A=jet(A,1)/s;
@@ -1072 +1121 @@
   ring R=0,(x,y),ds;
   poly t=x5+x2y2+y5;
-  list A=saito(t);
+  list A=tmatrix(t);
   print(A[1]);
   print(A[2]);
@@ -1078 +1127 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc endvfilt(list V)
-"USAGE:   endvfilt(V); list V
-ASSUME:  V computed by vfilt
+proc endvfilt(list v)
+"USAGE:   endvfilt(v); list v
+ASSUME:  v returned by vfilt
 RETURN:
 @format
-list EV: endomorphism V-filtration on the Jacobian algebra
-  ideal EV[1]: spectral numbers in increasing order
-  intvec EV[2]:
-    int EV[2][i]: multiplicity of spectral pair (EV[1][i],EV[2][i])
-  list EV[3]:
-    module EV[3][i]: vector space basis of the (EV[1][i],EV[2][i])-th 
-                      graded part in terms of EV[4]
-  ideal EV[4]: monomial vector space basis
-  ideal EV[5]: standard basis of Jacobian ideal
+list ev;  endomorphism V-filtration on Jacobian algebra
+  ideal ev[1];
+    number ev[1][i];  V-filtration index of i-th spectral pair
+  intvec ev[2]; 
+    int ev[2][i];  multiplicity of i-th spectral pair
+  list ev[3]; 
+    module ev[3][i];  vector space of i-th spectral pair in terms of ev[4]
+  ideal ev[4];  monomial vector space basis of Jacobian algebra
+  ideal ev[5];  standard basis of Jacobian ideal
 @end format
 KEYWORDS: singularities; Gauss-Manin connection; Brieskorn lattice;
           mixed Hodge structure; V-filtration; endomorphism filtration
-EXAMPLE: example endvfilt; shows examples
-"
-{
-  def a,d,v,m,g=V[1..5];
+EXAMPLE:  example endvfilt; shows examples
+"
+{
+  def a,d,V,m,g=v[1..5];
   int mu=ncols(m);
 
-  module V0=v[1];
-  for(int i=2;i<=size(v);i++)
-  {
-    V0=V0,v[i];
+  module V0=V[1];
+  for(int i=2;i<=size(V);i++)
+  {
+    V0=V0,V[i];
   }
 
@@ -1234 +1283 @@
 proc spprint(list sp)
 "USAGE:   spprint(sp); list sp
-RETURN:  string: spectrum sp
+RETURN:  string s;  spectrum sp
 EXAMPLE: example spprint; shows examples
 "
@@ -1256 +1305 @@
 proc sppprint(list spp)
 "USAGE:   sppprint(spp); list spp
-RETURN:  string: spectral pairs spp
+RETURN:  string s;  spectral pairs spp
 EXAMPLE: example sppprint; shows examples
 "
@@ -1277 +1326 @@
 
 proc spadd(list sp1,list sp2)
-"USAGE:   spadd(sp1,sp2); list sp1,sp2
-RETURN:  list: sum of spectra sp1 and sp2
+"USAGE:   spadd(sp1,sp2); list sp1, list sp2
+RETURN:  list sp;  sum of spectra sp1 and sp2
 EXAMPLE: example spadd; shows examples
 "
@@ -1350 +1399 @@
 
 proc spsub(list sp1,list sp2)
-"USAGE:   spsub(sp1,sp2); list sp1,sp2
-RETURN:  list: difference of spectra sp1 and sp2
+"USAGE:   spsub(sp1,sp2); list sp1, list sp2
+RETURN:  list sp;  difference of spectra sp1 and sp2
 EXAMPLE: example spsub; shows examples
 "
@@ -1369 +1418 @@
 
 proc spmul(list #)
-"USAGE:
-@format
-1) spmul(sp,k); list sp, int k
-2) spmul(sp,k); list sp, intvec k
-@end format
-RETURN:
-@format
-1) list: product of spectrum sp and integer k
-2) list: linear combination of spectra sp with coefficients k
-@end format
+"USAGE:   spmul(sp0,k); list sp0, int[vec] k
+RETURN:  list sp;  linear combination of spectra sp0 with coefficients k
 EXAMPLE: example spmul; shows examples
 "
@@ -1418 +1459 @@
 
 proc spissemicont(list sp,list #)
-"USAGE:   spissemicont(sp[,opt]); list sp, int opt
+"USAGE:   spissemicont(sp[,1]); list sp, int opt
 RETURN:
 @format
 int k=
-if opt=0:
-  1, if sum of spectrum sp over all intervals [a,a+1) is positive
-  0, if sum of spectrum sp over some interval [a,a+1) is negative
-if opt=1:
-  1, if sum of spectrum sp over all intervals [a,a+1) and (a,a+1) is positive
-  0, if sum of spectrum sp over some interval [a,a+1) or (a,a+1) is negative
-default: opt=0
+  1;  if sum of sp is positive on all intervals [a,a+1) [and (a,a+1)]
+  0;  if sum of sp is negative on some interval [a,a+1) [or (a,a+1)]
 @end format
 EXAMPLE: example spissemicont; shows examples
@@ -1481 +1517 @@
 
 proc spsemicont(list sp0,list sp,list #)
-"USAGE:   spsemicont(sp,k[,opt]); list sp0, list sp, int opt
-RETURN:  list of intvecs l:
-         spissemicont(sub(sp0,spmul(sp,k)),opt)==1 iff k<=l[i] for some i
+"USAGE:   spsemicont(sp0,sp,k[,1]); list sp0, list sp
+RETURN:
+@format
+list l;
+  intvec l[i];  if k<=l[i] then spissemicont(sub(sp0,spmul(sp,k))[,1])==1
+@end format
 NOTE:    if the spectra sp occur with multiplicities k in a deformation
-         of the [quasihomogeneous] spectrum sp0 then 
+         of the [quasihomogeneous] singularity with spectrum sp0 then 
          spissemicont(sub(sp0,spmul(sp,k))[,1])==1
 EXAMPLE: example spsemicont; shows examples
@@ -1554 +1593 @@
 proc spmilnor(list sp)
 "USAGE:   spmilnor(sp); list sp
-RETURN:  int: Milnor number of spectrum sp
+RETURN:  int mu;  Milnor number of spectrum sp
 EXAMPLE: example spmilnor; shows examples
 "
@@ -1571 +1610 @@
 proc spgeomgenus(list sp)
 "USAGE:   spgeomgenus(sp); list sp
-RETURN:  int: geometrical genus of spectrum sp
+RETURN:  int g;  geometrical genus of spectrum sp
 EXAMPLE: example spgeomgenus; shows examples
 "
@@ -1599 +1638 @@
 proc spgamma(list sp)
 "USAGE:   spgamma(sp); list sp
-RETURN:  number: gamma invariant of spectrum sp
+RETURN:  number gamma;  gamma invariant of spectrum sp
 EXAMPLE: example spgamma; shows examples
 "

Singular/LIB/linalg.lib

@@ -1 +1 @@
 //GMG last modified: 04/25/2000
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: linalg.lib,v 1.20 2001-11-05 09:17:05 mschulze Exp $";
+version="$Id: linalg.lib,v 1.21 2001-11-20 13:00:41 mschulze Exp $";
 category="Linear Algebra";
 info="
-LIBRARY:  linalg.lib        Algorithmic Linear Algebra
+LIBRARY:  linalg.lib  Algorithmic Linear Algebra
 AUTHORS:  Ivor Saynisch (ivs@math.tu-cottbus.de)
 @*        Mathias Schulze (mschulze@mathematik.uni-kl.de)
@@ -25 +25 @@
  U_D_O(A);            P*A=U*D*O, P,D,U,O=permutaion,diag,lower-,upper-triang
  pos_def(A,i);        test symmetric matrix for positive definiteness
- hessenberg(M);       transforms M to Hessenberg form
- spnf(a[,m][,v|V]);   normalize spectrum
- eigenvalues(M);      eigenvalues of M with multiplicities
- jordan(M);           Jordan data of constant square matrix M
- jordanbasis(M);      Jordan basis of constant square matrix M
- jordanmatrix(e,b);   Jordan matrix with eigenvalues e and Jordan block sizes b
- jordanform(M);       Jordan matrix of constant square matrix M
- commutator(A);       matrix of commutator B->[A,B]=AB-BA 
+ hessenberg(M);       Hessenberg form of M
+ spnf(a[,m][,V]);     spectrum normal form of (a,m,V)
+ eigenvals(M);        eigenvalues and multiplicities of M
+ jordan(M);           Jordan data of M
+ jordanbasis(M);      Jordan basis and weight filtration of M
+ jordanmatrix(e,b);   Jordan matrix with Jordan data (e,b)
+ jordannf(M);         Jordan normal form of M
 ";
 
@@ -1302 +1301 @@
 "USAGE:   hessenberg(M); matrix M
 ASSUME:  M constant square matrix
-RETURN:  matrix H in Hessenberg form with H=inverse(U)*M*U for some U
+RETURN:  matrix H;  Hessenberg form of M
 EXAMPLE: example hessenberg; shows examples
 "
@@ -1336 +1335 @@
 
 proc spnf(ideal e,list #)
-"USAGE:   spnf(e[,m][,v|V]); ideal e, intvec m, module v, list V
+"USAGE:   spnf(e[,m][,V]); ideal e, intvec m, list V of modules
+ASSUME:  ncols(e)=size(m)=size(V)
 RETURN:
 @format
-list Sp: normalized spectrum (e,m[,V])
-  ideal Sp[1]: numbers in a in increasing order
-  intvec Sp[2]:
-    int Sp[2][i]: multiplicity of number Sp[1][i] in e
-  list Spp[3]:
-    module Spp[3][i]: module associated to number Spp[1][i]
+list sp;  spectrum normal form of (e,m[,V])
+  ideal sp[1];  numbers in e in increasing order
+  intvec sp[2]; 
+    int sp[2][i];  multiplicity of number sp[1][i] in e
+  list sp[3]; 
+    module sp[3][i];  module associated to number sp[1][i]
 @end format
 EXAMPLE: example spnf; shows examples
@@ -1462 +1462 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc eigenvalues(matrix M)
-"USAGE:   eigenvalues(M); matrix M
-ASSUME:  M constant square matrix, eigenvalues of M in coefficient field
+proc eigenvals(matrix M)
+"USAGE:   eigenvals(M); matrix M
+ASSUME:  eigenvalues of M in basefield
 RETURN:
 @format
-list l:
-  ideal l[1]: eigenvalues of M
-  intvec l[2]:
-    int l[2][i]: multiplicity of eigenvalue l[1][i]
+list l; 
+  ideal l[1];  eigenvalues of M
+  intvec l[2]; 
+    int l[2][i];  multiplicity of eigenvalue l[1][i]
 @end format
-EXAMPLE: example eigenvalues; shows examples
+EXAMPLE: example eigenvals; shows examples
 "
 {
@@ -1530 +1530 @@
   matrix M[3][3]=3,2,1,0,2,1,0,0,3;
   print(M);
-  eigenvalues(M);
+  eigenvals(M);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -1536 +1536 @@
 proc jordan(matrix M,list #)
 "USAGE:   jordan(M); matrix M
-ASSUME:  M constant square matrix, eigenvalues of M in coefficient field
+ASSUME:  eigenvalues of M in basefield
 RETURN:
 @format
-list l:
-  ideal l[1]: eigenvalues of M in increasing order
-  intvec l[2]: corresponding Jordan block sizes
-  intvec l[3]: corresponding multiplicities 
+list l;  Jordan data of M
+  ideal l[1]; 
+    number l[1][i];  eigenvalue of i-th Jordan block of M
+  intvec l[2]; 
+    int l[2][i];  size of i-th Jordan block of M
+  intvec l[3]; 
+    int l[3][i];  multiplicity of i-th Jordan block of M
 @end format
 EXAMPLE: example jordan; shows examples
@@ -1560 +1563 @@
   if(size(#)==0)
   {
-    #=eigenvalues(M);
+    #=eigenvals(M);
   }
   def e0,m0=#[1..2];
@@ -1567 +1570 @@
   for(i=1;i<=ncols(e0);i++)
   {
-    if(deg(e0[i]>0))
-    {
+    if(deg(e0[i])>0)
+    {
+
       ERROR("eigenvalues in coefficient field expected");
       return(list());
@@ -1627 +1631 @@
 proc jordanbasis(matrix M,list #)
 "USAGE:   jordanbasis(M); matrix M
-ASSUME:  M constant square matrix, eigenvalues of M in coefficient field
+ASSUME:  eigenvalues of M in basefield
 RETURN:
 @format
 list l:
-  module l[1]: inverse(l[1])*M*l[1] has Jordan normal form
-  intvec l[2]: weight filtration indices of l[1] with center 0
+  module l[1];  inverse(l[1])*M*l[1] Jordan normal form
+  intvec l[2]; 
+    int l[2][i];  weight filtration index of l[1][i]
 @end format
 EXAMPLE: example jordanbasis; shows examples
@@ -1650 +1655 @@
   if(size(#)==0)
   {
-    #=eigenvalues(M);
+    #=eigenvals(M);
   }
   def e,m=#[1..2];
@@ -1726 +1731 @@
 proc jordanmatrix(ideal e,intvec s,intvec m)
 "USAGE:   jordanmatrix(e,s,m); ideal e, intvec s, intvec m
+ASSUME:  ncols(e)=size(s)=size(m)
 RETURN:
 @format
-matrix J: Jordan normal form with eigenvalues e and Jordan block sizes s
-          with multiplicities m
+matrix J;  Jordan matrix with eigenvalues e, Jordan block sizes s, 
+           and multiplicities m
 @end format
 EXAMPLE: example jordanmatrix; shows examples
@@ -1769 +1775 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc jordanform(matrix M,list #)
-"USAGE:   jordanform(M); matrix M
-ASSUME:  M constant square matrix, eigenvalues of M in coefficient field
-RETURN:  matrix J in Jordan normal form with J=inverse(U)*M*U for some U
-EXAMPLE: example jordanform; shows examples
+proc jordannf(matrix M,list #)
+"USAGE:   jordannf(M); matrix M
+ASSUME:  eigenvalues of M in basefield
+RETURN:  matrix J; Jordan normal form of M
+EXAMPLE: example jordannf; shows examples
 "
 {
@@ -1784 +1790 @@
   matrix M[3][3]=3,2,1,0,2,1,0,0,3;
   print(M);
-  print(jordanform(M));
-}
-///////////////////////////////////////////////////////////////////////////////
-
-proc commutator(matrix A)
-"USAGE:   (A); matrix A
-ASSUME:  A is a square matrix
-RETURN:  matrix C of the commutator B->[A,B]=AB-BA w.r.t. rowwise ordered basis
-EXAMPLE: example commutator; shows examples
-"
-{
-  int n=ncols(A);
-  if(n!=nrows(A))
-  {
-    ERROR("square matrix expected");
-  }
-  int i,j,k;
-  matrix C[n^2][n^2];
-  for(i=0;i<n;i++)
-  {
-    for(j=0;j<n;j++)
-    {
-      for(k=0;k<n;k++)
-      {
-        C[i*n+j+1,k*n+j+1]=C[i*n+j+1,k*n+j+1]+A[i+1,k+1];
-        C[i*n+j+1,i*n+k+1]=C[i*n+j+1,i*n+k+1]-A[k+1,j+1];
-      }
-    }
-  }
-  return(C);
-}
-example
-{ "EXAMPLE:"; echo=2;
-  ring R;
-  matrix A[2][2]=1,2,3,4;
-  print(A);
-  print(commutator(A));
-}
-
+  print(jordannf(M));
+}
 ///////////////////////////////////////////////////////////////////////////////