|
C.3 Syzygies and resolutions
Syzygies
Let
R be a quotient of Loc<K[x] and let I = (g1,...,gs) be a submodule of Rr. Then the module of
syzygies (or 1st syzygy module, module of relations) of I, syz(I), is defined to be the kernel
of the map Rs → Rr, ∑
i=1swiei ∑
i=1swigi.
The k-th syzygy module is defined inductively to be the module
of syzygies of the
(k − 1)-st
syzygy module.
Note, that the syzygy modules of I
depend on a choice of generators g1,...,gs. But one can show that they depend on I uniquely up to
direct summands.
Example:
ring R= 0,(u,v,x,y,z),dp;
ideal i=ux, vx, uy, vy;
print(syz(i));
→ -y,0, -v,0,
→ 0, -y,u, 0,
→ x, 0, 0, -v,
→ 0, x, 0, u
Free resolutions
Let I = (g1,...,gs) ⊆ Rr and M = Rr∕I. A free resolution of M is a long exact
sequence
where the columns of the matrix
A1
generate
I
. Note, that resolutions need not to be finite (i.e., of
finite length). The Hilbert Syzygy Theorem states, that for
R = Loc<K[x]
there exists a ("minimal") resolution of length not exceeding the number of
variables.
Example:
ring R= 0,(u,v,x,y,z),dp;
ideal I = ux, vx, uy, vy;
resolution resI = mres(I,0); resI;
→ 1 4 4 1
→ R <-- R <-- R <-- R
→
→ 0 1 2 3
→
// The matrix A_1 is given by
print(matrix(resI[1]));
→ vy,uy,vx,ux
// We see that the columns of A_1 generate I.
// The matrix A_2 is given by
print(matrix(resI[3]));
→ u,
→ -v,
→ -x,
→ y
Betti numbers and regularity
Let R be a graded ring (e.g., R = Loc<K[x]) and let I ⊂ Rr be a graded submodule.
Let
be a
minimal free resolution of Rn∕I considered with homogeneous maps of degree 0. Then the graded Betti number
bi,j of Rr∕I is the minimal number of generators ea,j in degree i + j of the j-th syzygy module of Rr∕I (i.e., the
(j − 1)-st syzygy module of I). Note, that by definition the 0-th syzygy module of Rr∕I is Rr and the 1st syzygy
module of Rr∕I is I.
The regularity of
I
is the smallest integer
s
such that
Example:
ring R= 0,(u,v,x,y,z),dp;
ideal I = ux, vx, uy, vy;
resolution resI = mres(I,0); resI;
→ 1 4 4 1
→ R <-- R <-- R <-- R
→
→ 0 1 2 3
→
// the betti number:
print(betti(resI), "betti");
→ 0 1 2 3
→ ------------------------------
→ 0: 1 - - -
→ 1: - 4 4 1
→ ------------------------------
→ total: 1 4 4 1
// the regularity:
regularity(resI);
→ 2
|