next | previous | forward | backward | up | top | index | toc | Macaulay2 website
Complexes :: naiveTruncation(ComplexMap,ZZ,ZZ)

naiveTruncation(ComplexMap,ZZ,ZZ) -- drops all terms in the source of a complex outside a given interval

Synopsis

Description

Naive truncations of complexes are functorial. Given a map of chain complexes, this method returns the canonical map from the naive truncation of the source to the naive truncation of the target. The degree of f is used to determine the appropriate naive truncation of the target complex.

First, we define some non-trivial maps of chain complexes.

i1 : R = ZZ/101[a..d];
i2 : C = (freeResolution coker matrix{{a,b,c}})[1]

      1      3      3      1
o2 = R  <-- R  <-- R  <-- R
                           
     -1     0      1      2

o2 : Complex
i3 : D = freeResolution coker matrix{{a*b,a*c,b*c}}

      1      3      2
o3 = R  <-- R  <-- R
                    
     0      1      2

o3 : Complex
i4 : E = freeResolution coker matrix{{a^2,b^2,c*d}}

      1      3      3      1
o4 = R  <-- R  <-- R  <-- R
                           
     0      1      2      3

o4 : Complex
i5 : f = randomComplexMap(D, C)

                    1
o5 = -1 : 0 <----- R  : -1
               0

          1                                                           3
     0 : R  <------------------------------------------------------- R  : 0
               | 24a-36b-30c-29d 19a+19b-10c-29d -8a-22b-29c-24d |

          3                          3
     1 : R  <---------------------- R  : 1
               {2} | -38 21 -47 |
               {2} | -16 34 -39 |
               {2} | 39  19 -18 |

          2                   1
     2 : R  <--------------- R  : 2
               {3} | -13 |
               {3} | -43 |

o5 : ComplexMap
i6 : g = randomComplexMap(E, D)

          1               1
o6 = 0 : R  <----------- R  : 0
               | -15 |

          3                          3
     1 : R  <---------------------- R  : 1
               {2} | -28 2  45  |
               {2} | -47 16 -34 |
               {2} | 38  22 -48 |

          3         2
     2 : R  <----- R  : 2
               0

o6 : ComplexMap
i7 : h = g * f

          1                                                           3
o7 = 0 : R  <------------------------------------------------------- R  : 0
               | 44a+35b+46c+31d 18a+18b+49c+31d 19a+27b+31c-44d |

          3                          3
     1 : R  <---------------------- R  : 1
               {2} | -41 32 24  |
               {2} | 2   22 -25 |
               {2} | -32 28 38  |

o7 : ComplexMap

We use these maps to illustrate naive truncation.

i8 : tf = naiveTruncation(f, 0, 1)

          1                                                           3
o8 = 0 : R  <------------------------------------------------------- R  : 0
               | 24a-36b-30c-29d 19a+19b-10c-29d -8a-22b-29c-24d |

          3                          3
     1 : R  <---------------------- R  : 1
               {2} | -38 21 -47 |
               {2} | -16 34 -39 |
               {2} | 39  19 -18 |

o8 : ComplexMap
i9 : tg = naiveTruncation(g, (0, 1))

          1               1
o9 = 0 : R  <----------- R  : 0
               | -15 |

          3                          3
     1 : R  <---------------------- R  : 1
               {2} | -28 2  45  |
               {2} | -47 16 -34 |
               {2} | 38  22 -48 |

o9 : ComplexMap
i10 : th = naiveTruncation(h, (0, 1))

           1                                                           3
o10 = 0 : R  <------------------------------------------------------- R  : 0
                | 44a+35b+46c+31d 18a+18b+49c+31d 19a+27b+31c-44d |

           3                          3
      1 : R  <---------------------- R  : 1
                {2} | -41 32 24  |
                {2} | 2   22 -25 |
                {2} | -32 28 38  |

o10 : ComplexMap
i11 : assert all({tf, tg, th}, isWellDefined)
i12 : assert(th == tg * tf)
i13 : t2f = naiveTruncation(f, -infinity, 1)

           1                                                           3
o13 = 0 : R  <------------------------------------------------------- R  : 0
                | 24a-36b-30c-29d 19a+19b-10c-29d -8a-22b-29c-24d |

           3                          3
      1 : R  <---------------------- R  : 1
                {2} | -38 21 -47 |
                {2} | -16 34 -39 |
                {2} | 39  19 -18 |

o13 : ComplexMap
i14 : assert(t2f == naiveTruncation(f,, 1))
i15 : assert(tf != t2f)

It is also possible to truncate the source and target independently.

i16 : t2f = naiveTruncation(f, (0,1), (1,2))

           3                          3
o16 = 1 : R  <---------------------- R  : 1
                {2} | -38 21 -47 |
                {2} | -16 34 -39 |
                {2} | 39  19 -18 |

o16 : ComplexMap
i17 : assert(source t2f == naiveTruncation(C, (1,2)))
i18 : assert(target t2f == naiveTruncation(D, (0,1)))

There is another type of truncation, canonical truncation, which induces an isomorphism on (a range) of homology.

See also