Home Online Manual
Top
Back: Polar curves
Forward: Deformations
FastBack: Commutative Algebra
FastForward: Invariant Theory
Up: Singularity Theory
Top: Singular Manual
Contents: Table of Contents
Index: Index
About: About this document

A.4.4 T1 and T2

$T^1$, resp. $T^2$, of an ideal $j$ usually denote the modules of infinitesimal deformations, resp. of obstructions. In SINGULAR there are procedures T_1 and T_2 in sing.lib such that T_1(j) and T_2(j) compute a standard basis of a presentation of these modules. If $T^1,T_2$ are finite dimensional K-vector spaces (e.g., for isolated singularities), a basis can be computed by applying kbase(T_1(j));, resp. kbase(T_2(j));, the dimensions by applying vdim. For a complete intersection j the procedure Tjurina also computes $T^1$, but faster ( $T^2=0$ in this case). For a non complete intersection, it is faster to use the procedure T_12 instead of T_1 and T_2. Type help T_1; (or help T_2; or help T_12;) to obtain more detailed information about these procedures.

We give three examples, the first being a hypersurface, the second a complete intersection, the third not a complete intersection:

  • load sing.lib
  • check whether the ideal j is a complete intersection. It is, if number of variables = dimension + minimal number of generators
  • compute the Tjurina number
  • compute a vector space basis (kbase) of $T^1$

  • compute the Hilbert function of $T^1$

  • create a polynomial encoding the Hilbert series
  • compute the dimension of $T^2$

 
  LIB "sing.lib";
  ring R=32003,(x,y,z),ds;
  // ---------------------------------------
  // hypersurface case (from series T[p,q,r]):
  int p,q,r = 3,3,4;
  poly f = x^p+y^q+z^r+xyz;
  tjurina(f);
==> 8
  // Tjurina number = 8
  kbase(Tjurina(f));
==> // Tjurina number = 8
==> _[1]=z3
==> _[2]=z2
==> _[3]=yz
==> _[4]=xz
==> _[5]=z
==> _[6]=y
==> _[7]=x
==> _[8]=1
  // ---------------------------------------
  // complete intersection case (from series P[k,l]):
  int k,l =3,2;
  ideal j=xy,x^k+y^l+z2;
  dim(std(j));          // Krull dimension
==> 1
  size(minbase(j));     // minimal number of generators
==> 2
  tjurina(j);           // Tjurina number
==> 6
  module T=Tjurina(j);
==> // Tjurina number = 6
  kbase(T);             // a sparse output of the k-basis of T_1
==> _[1]=z*gen(1)
==> _[2]=gen(1)
==> _[3]=y*gen(2)
==> _[4]=x2*gen(2)
==> _[5]=x*gen(2)
==> _[6]=gen(2)
  print(kbase(T));      // columns of matrix are a k-basis of T_1
==> z,1,0,0, 0,0,
==> 0,0,y,x2,x,1 
  // ---------------------------------------
  // general case (cone over rational normal curve of degree 4):
  ring r1=0,(x,y,z,u,v),ds;
  matrix m[2][4]=x,y,z,u,y,z,u,v;
  ideal i=minor(m,2);   // 2x2 minors of matrix m
  module M=T_1(i);       // a presentation matrix of T_1
==> // dim T_1 = 4
  vdim(M);              // Tjurina number
==> 4
  hilb(M);              // display of both Hilbert series
==> //         4 t^0
==> //       -20 t^1
==> //        40 t^2
==> //       -40 t^3
==> //        20 t^4
==> //        -4 t^5
==> 
==> //         4 t^0
==> // dimension (local)   = 0
==> // multiplicity = 4
  intvec v1=hilb(M,1);  // first Hilbert series as intvec
  intvec v2=hilb(M,2);  // second Hilbert series as intvec
  v1;
==> 4,-20,40,-40,20,-4,0
  v2;
==> 4,0
  v1[3];                // 3rd coefficient of the 1st Hilbert series
==> 40
  module N=T_2(i);
==> // dim T_2 = 3
 
// In some cases it might be useful to have a polynomial in some ring
// encoding the Hilbert series. This polynomial can then be
// differentiated, evaluated etc. It can be done as follows:
ring H = 0,t,ls;
poly h1;
int ii;
for (ii=1; ii<=size(v1); ii=ii+1)
{
   h1=h1+v1[ii]*t^(ii-1);
}
h1;                   // 1st Hilbert series
==> 4-20t+40t2-40t3+20t4-4t5
diff(h1,t);           // differentiate  h1
==> -20+80t-120t2+80t3-20t4
subst(h1,t,1);        // substitute t by 1
==> 0

// The procedures T_1, T_2, T_12 may be called with two arguments and then
// they return a list with more information (type help T_1; etc.)
// e.g., T_12(i,<any>); returns a list with 9 nonempty objects where
// _[1] = std basis of T_1-module, _[2] = std basis of T_2-module,
// _[3]= vdim of T_1, _[4]= vdim of T_2
setring r1;           // make r1 again the basering
list L = T_12(i,1);
==> // dim T_1  =  4
==> // dim T_2  =  3
kbase(L[1]);          // kbase of T_1
==> _[1]=1*gen(2)
==> _[2]=1*gen(3)
==> _[3]=1*gen(6)
==> _[4]=1*gen(7)
kbase(L[2]);          // kbase of T_2
==> _[1]=1*gen(6)
==> _[2]=1*gen(8)
==> _[3]=1*gen(9)
L[3];                 // vdim of T_1
==> 4
L[4];                 // vdim of T_2
==> 3