Description
This is one of the algorithms written at top level of Macaulay2 for computing free resolutions, although it uses engine code to compute free resolutions of the homogenized module or ideal. This is the default strategy for inhomogeneous ideals or modules over a commutative ring. The result is rarely a minimal resolution; minimal resolutions are not generally defined in the inhomogeneous case.
This first example computes a free resolution of an inhomogeneous ideal.
i1 : kk = ZZ/53;
|
i2 : S = kk[a,b,c,d];
|
i3 : I = ideal(a^3-b^2-a*c, a*b*c-d^2, a^3-d^2)
3 2 2 3 2
o3 = ideal (a - b - a*c, a*b*c - d , a - d )
o3 : Ideal of S
|
i4 : M = S^1/I
o4 = cokernel | a3-b2-ac abc-d2 a3-d2 |
1
o4 : S-module, quotient of S
|
i5 : F = freeResolution M
1 4 5 2
o5 = S <-- S <-- S <-- S
0 1 2 3
o5 : Complex
|
i6 : dd^F
1 4
o6 = 0 : S <--------------------------------------- S : 1
| b2+ac-d2 a3-d2 abc-d2 a2d2-bcd2 |
4 5
1 : S <------------------------------------------------- S : 2
{2} | -a3+d2 0 abc-d2 0 -a2d2+bcd2 |
{3} | b2+ac-d2 -bc 0 -d2 cd2 |
{3} | 0 a2 -b2-ac+d2 d2 -cd2 |
{4} | 0 1 0 a b2-d2 |
5 2
2 : S <---------------------------- S : 3
{5} | -d2 -bc |
{5} | 0 -b2-ac+d2 |
{5} | -d2 -a2 |
{5} | -b2+d2 c |
{6} | a 1 |
o6 : ComplexMap
|
i7 : assert isWellDefined F
|
i8 : assert isQuasiIsomorphism(augmentationMap F, Concentration => (0,4))
|
Even though minimal resolutions are not generally defined, the minimize method will often produce a smaller resolution.
i9 : mF = minimize F
1 3 3 1
o9 = S <-- S <-- S <-- S
0 1 2 3
o9 : Complex
|
i10 : dd^mF
1 3
o10 = 0 : S <----------------------------- S : 1
| b2+ac-d2 a3-d2 abc-d2 |
3 3
1 : S <--------------------------------- S : 2
| -a3+d2 abc-d2 0 |
| b2+ac-d2 0 abc-d2 |
| 0 -b2-ac+d2 -a3+d2 |
3 1
2 : S <----------------- S : 3
| abc-d2 |
| a3-d2 |
| -b2-ac+d2 |
o10 : ComplexMap
|
i11 : assert isWellDefined mF
|
i12 : prune HH mF
o12 = cokernel | b2+ac-d2 abc-d2 a3-d2 |
0
o12 : Complex
|
When the input is an ideal $I$, the free resolution of $S^1/I$ is returned.
i13 : F1 = freeResolution I
1 4 5 2
o13 = S <-- S <-- S <-- S
0 1 2 3
o13 : Complex
|
i14 : assert(F1 == F)
|
i15 : F2 = freeResolution module I
3 4 2
o15 = S <-- S <-- S
0 1 2
o15 : Complex
|
i16 : dd^F1
1 4
o16 = 0 : S <--------------------------------------- S : 1
| b2+ac-d2 a3-d2 abc-d2 a2d2-bcd2 |
4 5
1 : S <------------------------------------------------- S : 2
{2} | -a3+d2 0 abc-d2 0 -a2d2+bcd2 |
{3} | b2+ac-d2 -bc 0 -d2 cd2 |
{3} | 0 a2 -b2-ac+d2 d2 -cd2 |
{4} | 0 1 0 a b2-d2 |
5 2
2 : S <---------------------------- S : 3
{5} | -d2 -bc |
{5} | 0 -b2-ac+d2 |
{5} | -d2 -a2 |
{5} | -b2+d2 c |
{6} | a 1 |
o16 : ComplexMap
|
i17 : dd^F2
3 4
o17 = 0 : S <----------------------------------------------------- S : 1
{3} | -abc+d2 -a3+d2 -abc+d2 -a2d2+bcd2 |
{3} | a3-b2-ac 0 -b2-ac+d2 a2b2-a2d2+cd2 |
{3} | 0 a3-b2-ac abc-d2 -b3c+a2d2-cd2 |
4 2
1 : S <----------------------- S : 2
{6} | -b2+d2 c |
{6} | -d2 -bc |
{6} | b2 a2-c |
{7} | a 1 |
o17 : ComplexMap
|
This strategy also works over quotient rings.
i18 : R = S/(a^4-a*d, b^3-a*d)
o18 = R
o18 : QuotientRing
|
i19 : I = ideal(a^3-b^2-a*c, a*b*c-d*a, a^3+d^2)
3 2 3 2
o19 = ideal (a - b - a*c, a*b*c - a*d, a + d )
o19 : Ideal of R
|
i20 : M = R^1/I
o20 = cokernel | a3-b2-ac abc-ad a3+d2 |
1
o20 : R-module, quotient of R
|
i21 : F = freeResolution(M, Strategy => Homogenization, LengthLimit => 4)
1 8 16 22 30
o21 = R <-- R <-- R <-- R <-- R
0 1 2 3 4
o21 : Complex
|
i22 : assert isWellDefined F
|
i23 : dd^F_2
o23 = {2} | -1 0 -d2 cd -bd -bc -b2-ac-d2 -a2 -d-1 cd 0 0 -c2d 0 0
{2} | b 0 0 -d2 0 0 ad 0 0 -ac 0 0 0 0 0
{3} | 0 -b a d 0 0 0 -1 0 0 -c2 0 0 0 0
{3} | -1 d 0 b a 0 0 0 0 0 0 -c2 0 0 -c
{3} | -1 0 0 0 0 d 0 0 0 b 0 0 0 0 -a2
{3} | 0 0 0 0 0 0 0 d a 0 0 0 0 -c2 bc
{4} | 0 0 0 0 0 0 0 0 0 0 d b a 1 0
{4} | 0 0 0 0 0 0 0 0 0 1 0 0 0 a 0
-----------------------------------------------------------------------
a2d+cd+c |
-a3-d2 |
d |
0 |
0 |
b2 |
0 |
0 |
8 16
o23 : Matrix R <-- R
|
This strategy homogenizes the ideal or module as well as the underlying ring, calls an engine routine to compute the resolution, and finally dehomogenizes the result.