
A.3.6 Computation of Ext
We start by showing how to calculate the nth 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 nth 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 (n1)st map is generated by the columns of the
corresponding matrix. To calculate the kernel apply the command
syz at the (n1)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
Extmodules 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=x2y3;
qring q = std(i); // defines the quotient ring k[x,y]_m/(x2y3)
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 3rd 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

