next | previous | forward | backward | up | top | index | toc | Macaulay2 website
ExactCouples :: TorCouple

TorCouple -- the exact couple obtained by applying Tor(W,-) to a filtered module

Synopsis

Description

For notational convenience, set $X = A_m$, and extend the sequence $A_i$ to all $i \in \ZZ$ by setting $A_i = 0$ for $i < 0$, and $A_i = X$ for $i > m$.

The returned couple $M$ is a module for the ring R[e_1,f_1,Degrees=>{{-1,-1},{0,2}}]. We describe the module $M$ in every bidegree $(s,t)$. The description depends on the parity of $s$ and $t$.

If $s$ and $t$ are both even, say $(s,t) = (2p, 2q)$, then

$M_{s,t} = Tor_p(W,A_q/A_{q-1})$;

if $s$ and $t$ are both odd, say $(s,t) = (2p+1,2q+1)$, then

$M_{s,t} = Tor_p(W,A_q)$;

and otherwise, if $s$ and $t$ sum to an odd number, then $M_{s,t} = 0$.

The variables $e_1$ and $f_1$ act by the maps in the various long exact sequences

$Tor_p(W, A_{q-1}) \to Tor_p(W, A_q) \to Tor_p(W, A_q / A_{q-1}) \to Tor_{p-1}(W, A_{q-1})$.

Associated spectral sequence

The spectral sequence associated to this couple converges to $Tor_p(W,X)$. The differential on page $r$ has bidegree $(-1,-r)$. The first page has

$E^{pq}_1 = Tor_p(W,A_q/A_{q-1})$.

Setting $F^p_q = image(Tor_p(W,A_q) \to Tor_p(W,X))$, the infinity page has

$E^{p,q}_{\infty} = F^p_{q} / F^p_{q-1}$.

i1 : R = QQ[x]

o1 = R

o1 : PolynomialRing
i2 : X = R^1 / x^9

o2 = cokernel | x9 |

                            1
o2 : R-module, quotient of R
i3 : submods = apply(5,k->image map(X,,{{x^(8-2*k)}}));
i4 : for m in submods do print m;
subquotient (| x8 |, | x9 |)
subquotient (| x6 |, | x9 |)
subquotient (| x4 |, | x9 |)
subquotient (| x2 |, | x9 |)
subquotient (| 1 |, | x9 |)
i5 : W = coker map(R^1,,{{x^3}})

o5 = cokernel | x3 |

                            1
o5 : R-module, quotient of R
i6 : couple = prune TorCouple(W,submods)
warning: clearing value of symbol f to allow access to subscripted variables based on it
       : debug with expression   debug 3406   or with command line option   --debug 3406

o6 = cokernel {3, 1, 11} | x e_1^2 f_1 0     0 0   0   0   0     0      0     0  0   0   0     0  0   0   0     0  0   0   0     0   0     0     0     0     0     0      |
              {3, 3, 9}  | 0 0     -x2 e_1^2 0 0   0   0   x2e_1 e_1f_1 0     0  0   0   0     0  0   0   0     0  0   0   0     0   0     0     0     0     0     0      |
              {1, 1, 8}  | 0 0     0   0     x 0   0   0   0     0      e_1^2 0  0   f_1 0     0  0   0   0     0  0   0   0     0   0     0     0     0     0     0      |
              {2, 4, 7}  | 0 0     0   0     0 e_1 0   0   0     0      0     x2 f_1 0   0     0  0   0   0     0  0   0   0     0   0     0     0     0     0     0      |
              {1, 3, 6}  | 0 0     0   0     0 x   0   0   0     0      0     0  0   -x2 e_1^2 0  0   f_1 0     0  0   0   0     0   0     x2e_1 0     0     0     0      |
              {2, 6, 5}  | 0 0     0   0     0 0   e_1 0   0     0      0     0  0   0   0     x2 f_1 0   0     0  0   0   0     0   0     0     0     0     0     0      |
              {1, 5, 4}  | 0 0     0   0     0 0   x   0   0     0      0     0  0   0   0     0  0   -x2 e_1^2 0  0   f_1 0     0   0     0     x2e_1 0     0     0      |
              {2, 8, 3}  | 0 0     0   0     0 0   0   e_1 0     0      0     0  0   0   0     0  0   0   0     x2 f_1 0   0     0   0     0     0     0     0     0      |
              {1, 7, 2}  | 0 0     0   0     0 0   0   x   0     0      0     0  0   0   0     0  0   0   0     0  0   -x2 e_1^2 f_1 0     0     0     x2e_1 0     0      |
              {1, 9, 0}  | 0 0     0   0     0 0   0   0   0     0      0     0  0   0   0     0  0   0   0     0  0   0   0     -x2 e_1^2 0     0     0     x2e_1 e_1f_1 |

                                              10
o6 : R[e , f ]-module, quotient of (R[e , f ])
        1   1                          1   1
i7 : expectExactCouple couple
i8 : plotPages((-1..2,-1..5,1..3), prune @@ evaluateInDegree, couple)
warning: clearing value of symbol e to allow access to subscripted variables based on it
       : debug with expression   debug 3903   or with command line option   --debug 3903
warning: clearing value of symbol f to allow access to subscripted variables based on it
       : debug with expression   debug 3406   or with command line option   --debug 3406
page 1, with differential of degree {-1, -1}:
+----++----+-------------------+-------------------+---+
|q=5 ||0   |0                  |0                  |0  |
+----++----+-------------------+-------------------+---+
|q=4 ||0   |cokernel | x2 |    |cokernel {3} | x2 ||0  |
+----++----+-------------------+-------------------+---+
|q=3 ||0   |cokernel {2} | x2 ||cokernel {5} | x2 ||0  |
+----++----+-------------------+-------------------+---+
|q=2 ||0   |cokernel {4} | x2 ||cokernel {7} | x2 ||0  |
+----++----+-------------------+-------------------+---+
|q=1 ||0   |cokernel {6} | x2 ||cokernel {9} | x2 ||0  |
+----++----+-------------------+-------------------+---+
|q=0 ||0   |cokernel {8} | x | |cokernel {11} | x ||0  |
+----++----+-------------------+-------------------+---+
|q=-1||0   |0                  |0                  |0  |
+----++----+-------------------+-------------------+---+
|    ||p=-1|p=0                |p=1                |p=2|
+----++----+-------------------+-------------------+---+

page 2, with differential of degree {-1, -2}:
+----++----+------------------+-------------------+---+
|q=5 ||0   |0                 |0                  |0  |
+----++----+------------------+-------------------+---+
|q=4 ||0   |cokernel | x2 |   |cokernel {4} | x | |0  |
+----++----+------------------+-------------------+---+
|q=3 ||0   |cokernel {2} | x ||cokernel {6} | x | |0  |
+----++----+------------------+-------------------+---+
|q=2 ||0   |cokernel {4} | x ||cokernel {8} | x | |0  |
+----++----+------------------+-------------------+---+
|q=1 ||0   |cokernel {6} | x ||cokernel {9} | x2 ||0  |
+----++----+------------------+-------------------+---+
|q=0 ||0   |cokernel {8} | x ||cokernel {11} | x ||0  |
+----++----+------------------+-------------------+---+
|q=-1||0   |0                 |0                  |0  |
+----++----+------------------+-------------------+---+
|    ||p=-1|p=0               |p=1                |p=2|
+----++----+------------------+-------------------+---+

page 3, with differential of degree {-1, -3}:
+----++----+------------------+-------------------+---+
|q=5 ||0   |0                 |0                  |0  |
+----++----+------------------+-------------------+---+
|q=4 ||0   |cokernel | x2 |   |0                  |0  |
+----++----+------------------+-------------------+---+
|q=3 ||0   |cokernel {2} | x ||0                  |0  |
+----++----+------------------+-------------------+---+
|q=2 ||0   |0                 |0                  |0  |
+----++----+------------------+-------------------+---+
|q=1 ||0   |0                 |cokernel {9} | x2 ||0  |
+----++----+------------------+-------------------+---+
|q=0 ||0   |0                 |cokernel {11} | x ||0  |
+----++----+------------------+-------------------+---+
|q=-1||0   |0                 |0                  |0  |
+----++----+------------------+-------------------+---+
|    ||p=-1|p=0               |p=1                |p=2|
+----++----+------------------+-------------------+---+
i9 : A = i -> if i < 0 then image(0*id_X) else if i >= #submods then X else submods#i;
i10 : E1 = (q,p) -> prune Tor_p(W,A(q)/A(q-1));
i11 : netList reverse table(5,2,E1)

      +-------------------+-------------------+
o11 = |cokernel | x2 |    |cokernel {3} | x2 ||
      +-------------------+-------------------+
      |cokernel {2} | x2 ||cokernel {5} | x2 ||
      +-------------------+-------------------+
      |cokernel {4} | x2 ||cokernel {7} | x2 ||
      +-------------------+-------------------+
      |cokernel {6} | x2 ||cokernel {9} | x2 ||
      +-------------------+-------------------+
      |cokernel {8} | x | |cokernel {11} | x ||
      +-------------------+-------------------+
i12 : inc = q -> inducedMap(X,A(q));
i13 : filt = (p,q) -> image Tor_p(W,inc q); --no method for this?
i14 : Einfty = (q,p) -> prune(filt(p,q)/filt(p,q-1));

There is also a more-general method available where the argument submods is replaced by a module for a ring of the form R[f]. If f acts by inclusions, we recover the case above, but if not, then we still obtain an exact couple from relative homology.

See also

Ways to use TorCouple:

For the programmer

The object TorCouple is a method function.