Macaulay2 » Documentation
Packages » Complexes :: canonicalTruncation(ComplexMap,ZZ,ZZ)
next | previous | forward | backward | up | index | toc

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

Description

Returns a new complex map (commuting with the differentials) 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,a*b*c,b*c*d}})[-1]

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

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

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

          1                         3
     0 : R  <--------------------- R  : 0
               | 24a -36b -30c |

          3                          3
     1 : R  <---------------------- R  : 1
               {2} | -41 0   0  |
               {2} | 0   -47 0  |
               {2} | 0   0   -6 |

          2                   1
     2 : R  <--------------- R  : 2
               {3} | -41 |
               {3} | 6   |

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

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

          1                                               3
     1 : R  <------------------------------------------- R  : 1
               | -29ab+19bd -10a2-8ac-22cd 19ab-29bc |

          3                       2
     2 : R  <------------------- R  : 2
               {3} | 10  -29 |
               {3} | -21 21  |
               {3} | 41  -22 |

o6 : ComplexMap
 
i7 : h = g * f

          1                                                 3
o7 = 1 : R  <--------------------------------------------- R  : 1
               | -23ab+29bd -35a2-28ac+24cd -13ab-28bc |

          3                   1
     2 : R  <--------------- R  : 2
               {3} | 22  |
               {3} | -23 |
               {3} | 5   |

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
               | 41ab 6bc 47ac |         {1} | a  -c 0  |
                                         {1} | 0  b  a  |

     1 : cokernel {2} | -c 0  | <---------------------- cokernel {2} | -c | : 1
                  {2} | b  -b |    {2} | -41 0   0  |            {2} | b  |
                  {2} | 0  a  |    {2} | 0   -47 0  |            {2} | -a |
                                   {2} | 0   0   -6 |

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

o9 = 1 : cokernel | -a2b -abc -bcd | <------------------------------------------- cokernel {2} | -c 0  | : 1
                                        | -29ab+19bd -10a2-8ac-22cd 19ab-29bc |            {2} | b  -b |
                                                                                           {2} | 0  a  |

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

o10 = 1 : cokernel | -a2b -abc -bcd | <--------------------------------------------- cokernel {2} | -c | : 1
                                         | -23ab+29bd -35a2-28ac+24cd -13ab-28bc |            {2} | b  |
                                                                                              {2} | -a |

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 |

      1 : cokernel {2} | -c 0  | <---------------------- cokernel {2} | -c | : 1
                   {2} | b  -b |    {2} | -41 0   0  |            {2} | b  |
                   {2} | 0  a  |    {2} | 0   -47 0  |            {2} | -a |
                                    {2} | 0   0   -6 |

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

Ways to use this method:

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

The source of this document is in /build/reproducible-path/macaulay2-1.26.05+ds/M2/Macaulay2/packages/Complexes/ChainComplexMapDoc.m2:1627:0.