### A.3.6 Computation of Ext

We start by showing how to calculate the n-th Ext group of an ideal. The ingredients to do this are by the definition of Ext the following: calculate a (minimal) resolution at least up to length n, apply the Hom functor, and calculate the n-th homology group, that is, form the quotient ker/im in the resolution sequence.

The Hom functor is given simply by transposing (hence dualizing) the module or the corresponding matrix with the command `transpose`. The image of the (n-1)-st map is generated by the columns of the corresponding matrix. To calculate the kernel apply the command `syz` at the (n-1)-st transposed entry of the resolution. Finally, the quotient is obtained by the command `modulo`, which gives for two modules A = ker, B = Im the module of relations of

in the usual way. As we have a chain complex, this is obviously the same as ker/Im.

We collect these statements in the following short procedure:

    proc ext(int n, ideal I)
    {
      resolution rs = mres(I,n+1);
      module tAn    = transpose(rs[n+1]);
      module tAn_1  = transpose(rs[n]);
      module ext_n  = modulo(syz(tAn),tAn_1);
      return(ext_n);
    }

Now consider the following example:

    ring r5 = 32003,(a,b,c,d,e),dp;
    ideal I = a2b2+ab2c+b2cd, a2c2+ac2d+c2de,a2d2+ad2e+bd2e,a2e2+abe2+bce2;
    print(ext(2,I));
    ==> 1,0,0,0,0,0,0,
    ==> 0,1,0,0,0,0,0,
    ==> 0,0,1,0,0,0,0,
    ==> 0,0,0,1,0,0,0,
    ==> 0,0,0,0,1,0,0,
    ==> 0,0,0,0,0,1,0,
    ==> 0,0,0,0,0,0,1
    ext(3,I);   // too big to be displayed here

The library `homolog.lib` contains several procedures for computing Ext-modules and related modules, which are much more general and sophisticated than the above one. They are used in the following example:

If is a module, then , resp. ,are the modules of infinitesimal deformations, respectively of obstructions, of (like T1 and T2 for a singularity). Similar to the treatment of singularities, the semiuniversal deformation of can be computed (if is finite dimensional) with the help of , and the cup product. There is an extra procedure for if is an ideal in , since this is faster than the general Ext.

We compute

- the infinitesimal deformations ( )and obstructions ( )of the residue field of an ordinary cusp, , .To compute we have to apply `Ext(1,syz(m),syz(m))` with `syz(m)` the first syzygy module of , which is isomorphic to .
- for some ideal and with an extra option.

      LIB "homolog.lib";
      ring R=0,(x,y),ds;
      ideal i=x2-y3;
      qring q = std(i);      // defines the quotient ring k[x,y]_m/(x2-y3)
      ideal m = maxideal(1);
      module T1K = Ext(1,m,m);  // computes Ext^1(R/m,R/m)
    ==> // dimension of Ext^1:  0
    ==> // vdim of Ext^1:       2
    ==>
      print(T1K);
    ==> 0,x,0,y,
    ==> x,0,y,0
      printlevel=2;             // gives more explanation
      module T2K=Ext(2,m,m);    // computes Ext^2(R/m,R/m)
    ==> // Computing Ext^2 (help Ext; gives an explanation):
    ==> // Let 0<--coker(M)<--F0<--F1<--F2<--... be a resolution of coker(M),
    ==> // and 0<--coker(N)<--G0<--G1 a presentation of coker(N),
    ==> // then Hom(F2,G0)-->Hom(F3,G0) is given by:
    ==> y2,x,
    ==> x, y
    ==> // and Hom(F1,G0) + Hom(F2,G1)-->Hom(F2,G0) is given by:
    ==> -y,x,  x,0,y,0,
    ==> x, -y2,0,x,0,y
    ==>
    ==> // dimension of Ext^2:  0
    ==> // vdim of Ext^2:       2
    ==>
      print(std(T2K));
    ==> 0,x,0,y,
    ==> x,0,y,0
      printlevel=0;
      module E = Ext(1,syz(m),syz(m));
    ==> // dimension of Ext^1:  0
    ==> // vdim of Ext^1:       2
    ==>
      print(std(E));
    ==> 0,0,0,x,0,y,
    ==> 0,0,x,0,y,0,
    ==> 0,1,0,0,0,0,
    ==> 1,0,0,0,0,0
      //The matrices which we have just computed are presentation matrices
      //of the modules T2K and E. Hence we may ignore those columns
      //containing 1 as an entry and see that T2K and E are isomorphic
      //as expected, but differently presented.
      //-------------------------------------------
      ring S=0,(x,y,z),dp;
      ideal  i = x2y,y2z,z3x;
      module E = Ext_R(2,i);
    ==> // dimension of Ext^2:  1
    ==>
      print(E);
    ==> 0,y,0,z2,
    ==> z,0,0,-x,
    ==> 0,0,x,-y
      // if a 3-rd argument of type int is given,
      // a list of Ext^k(R/i,R), a SB of Ext^k(R/i,R) and a vector space basis
      // is returned:
      list LE = Ext_R(3,i,0);
    ==> // dimension of Ext^3:  0
    ==> // vdim of Ext^3:       2
    ==>
      LE;
    ==> [1]:
    ==>    _[1]=y*gen(1)
    ==>    _[2]=x*gen(1)
    ==>    _[3]=z2*gen(1)
    ==> [2]:
    ==>    _[1]=y*gen(1)
    ==>    _[2]=x*gen(1)
    ==>    _[3]=z2*gen(1)
    ==> [3]:
    ==>    _[1,1]=z
    ==>    _[1,2]=1
      print(LE[2]);
    ==> y,x,z2
      print(kbase(LE[2]));
    ==> z,1

User manual for Singular version 4.4.1, 2025, generated by texi2html.