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

canonicalTruncation(ComplexMap,ZZ,ZZ) -- reducing the number of non-zero terms of a complex

Synopsis

Description

Returns a new complex map which drops (sets to zero) all modules outside the given range in the source, and modifies the ends to preserve homology in the given range. The degree of the map f is used to determine the truncation of the target.

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 canonical truncation.

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

          1
o8 = 0 : R  <--------------------------------------------------------------------------------------------------------------- image {1} | -b 0  -c | : 0
               | 19a2-5ab+36b2-10ac+30bc-29ad+29bd -8ab-22b2-19ac-48bc+10c2-24bd+29cd -8a2-22ab+48ac+36bc+30c2-24ad+29cd |         {1} | a  -c 0  |
                                                                                                                                   {1} | 0  b  a  |

     1 : cokernel {2} | -c 0  | <---------------------- cokernel {2} | -c | : 1
                  {2} | b  -b |    {2} | -38 21 -47 |            {2} | b  |
                  {2} | 0  a  |    {2} | -16 34 -39 |            {2} | -a |
                                   {2} | 39  19 -18 |

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

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

     1 : cokernel {2} | -b2 -cd 0   | <---------------------- cokernel {2} | -c 0  | : 1
                  {2} | a2  0   -cd |    {2} | -28 2  45  |            {2} | b  -b |
                  {2} | 0   a2  b2  |    {2} | -47 16 -34 |            {2} | 0  a  |
                                         {2} | 38  22 -48 |

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

           1
o10 = 0 : R  <---------------------------------------------------------------------------------------------------------------- image {1} | -b 0  -c | : 0
                | 18a2-26ab-35b2+49ac-46bc+31ad-31bd 19ab+27b2-18ac+13bc-49c2-44bd-31cd 19a2+27ab-13ac-35bc-46c2-44ad-31cd |         {1} | a  -c 0  |
                                                                                                                                     {1} | 0  b  a  |

      1 : cokernel {2} | -b2 -cd 0   | <---------------------- cokernel {2} | -c | : 1
                   {2} | a2  0   -cd |    {2} | -41 32 24  |            {2} | b  |
                   {2} | 0   a2  b2  |    {2} | 2   22 -25 |            {2} | -a |
                                          {2} | -32 28 38  |

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

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

      1 : cokernel {2} | -c 0  | <---------------------- cokernel {2} | -c | : 1
                   {2} | b  -b |    {2} | -38 21 -47 |            {2} | b  |
                   {2} | 0  a  |    {2} | -16 34 -39 |            {2} | -a |
                                    {2} | 39  19 -18 |

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

There is another type of truncation, naive truncation, which yields a short exact sequence of complexes.

See also