up previous next
Ext 
presentation Ext modules as quotients of free modules

Ext(I: INT, M:TAGGED("Quotient"), Q:TAGGED("Quotient")): TAGGED("Quotient")
Ext(I: LIST, M:TAGGED("Quotient"), Q:TAGGED("Quotient")): TAGGED("$ext.ExtList")

***** NOT YET IMPLEMENTED *****
In the first form the function computes the
I
th Ext module of
M
and
N
.
It returns a presentation of
Ext^I_R(M, N) as a quotient of a free module.
IMPORTANT: the only exception to the type of
M
or
N
(or even of the
output) is when they are either a zero module or a free module.
In these cases their type is indeed MOD.
It computes Ext via a presentation of the quotient of the two modules
Ker(Phi*_I)
and
Im(Phi*_{I1}), where

Phi_I is the
I
th map in the free resolution of
M

Phi*_I is the map
Hom(Phi_I, N)
in the dual of the free resolution.
The main differences with the previous version include:
 SHIFTS have been removed, consequently only standard homogeneous
modules and quotients are supported
 as a consequence of 1), the type
Tagged("Shifted")
has been
removed. Ext will just be a
Tagged("Quotient")
 The former functions Presentation(), HomPresentation() and
KerPresentation() have been removed
 The algorithm uses Res() to compute the maps needed, and not
SyzOfGens anylonger, believed to cause troubles
 The function
Ext
always has THREE variables, see syntax...
In the second form the variable I is a LIST of nonnegative
integers. In this case the function Ext prints all the Ext modules
corresponding to the integers in I.
The output is of special type
Tagged("$ext.ExtList")
which is basically
just the list of pairs
{(J, Ext^J(M, N))  J in I} in
which the first element is an integer of
I
and the second element is
the correpsonding Ext module.
VERY IMPORTANT: CoCoA cannot accept the ring
R
as one of the inputs,
so if you want to calculate the module
Ext^I_R(M, R)
you need to type something like
Ext(I, M, ideal(1));
or
Ext(I, M, R^1);
or
Ext(I, M, R/ideal(0));
NOTE: The input is pretty flexible in terms of what you can use for
M
and
N
. For example, they can be zero modules or free modules.See some examples below.
/**/ use R ::= QQ[x,y,z];
/**/ I := ideal(x^5, y^3, z^2);
/**/ ideal(R, []) : (I);
ideal(0)

***** NOT YET IMPLEMENTED *****
$hom.Hom(R^1/Module(I), R^1);  from Hom package
Module([[0]])

Ext(0, R/I, R^1);  all those things should be isomorphic
Module([[0]])

Ext(0..4, R/I, R/ideal(0));  another way to define the ring R as a quotient
Ext^0 = Module([[0]])
Ext^1 = Module([[0]])
Ext^2 = Module([[0]])
Ext^3 = R^1/Module([[x^5], [y^3], [z^2]])
Ext^4 = Module([[0]])

N := Module([x^2,y], [x+z,0]);
Ext(0..4, R/I, R^2/N);
Ext^0 = Module([[0]])
Ext^1 = Module([[0]])
Ext^2 = R^2/Module([[0, x + z], [y, 0], [0, z^2], [z^2, 0], [0, y^3], [x^5, 0]])
Ext^3 = R^2/Module([[x + z, 0], [0, z^2], [z^2, 0], [y^3, 0], [0, x^5], [0, y]])
Ext^4 = Module([[0]])


Since version 4.7.3 the output modules are presented minimally.