truncate(List,Matrix) -- truncation of a map of free modules

Synopsis

Function: truncate
Usage:

truncate(degs, f)
Inputs:
- degs, a list, an integer or a list, a single degree, a multidegree, or a list of degrees or multidegrees
- f, a matrix, a graded map between graded modules (not necessarily free modules)
Optional inputs:
- MinimalGenerators => a Boolean value, default value true, indicates whether the source and target of the result should be trimmed
Outputs:
- a matrix, a graded map between the truncations of the source and target of $f$

Description

This function truncates the source and target of a module map, and returns the induced map between them.

i1 : R = ZZ/101[a..d, Degrees => {{1,3},{1,0},{1,3},{1,2}}];

i2 : I = ideal "a,b2,c3,d4"

                2   3   4
o2 = ideal (a, b , c , d )

o2 : Ideal of R

i3 : C = res I

      1      4      6      4      1
o3 = R  <-- R  <-- R  <-- R  <-- R  <-- 0
                                         
     0      1      2      3      4      5

o3 : ChainComplex

i4 : g1 = truncate({1,1}, C.dd_1)

o4 = {1, 2} | 0 b2 0  0  0  d3 |
     {1, 3} | 0 0  b2 0  c2 0  |
     {1, 3} | 1 0  0  b2 0  0  |

o4 : Matrix

i5 : g2 = truncate({1,1}, C.dd_2)

o5 = {1, 3} | -b2 -c3 0   -d4 0   0   |
     {3, 2} | 0   0   0   0   -d3 0   |
     {3, 3} | 0   0   -c2 0   0   0   |
     {3, 3} | 1   0   0   0   0   0   |
     {3, 9} | 0   a   b2  0   0   -d4 |
     {4, 8} | 0   0   0   a   b2  c3  |

o5 : Matrix

i6 : g3 = truncate({1,1}, C.dd_3)

o6 = {3, 3}  | c3  d4  0   0   |
     {4, 12} | -b2 0   d4  0   |
     {5, 9}  | a   0   0   d4  |
     {5, 11} | 0   -b2 -c3 0   |
     {6, 8}  | 0   a   0   -c3 |
     {7, 17} | 0   0   a   b2  |

o6 : Matrix

i7 : g4 = truncate({1,1}, C.dd_4)

o7 = {6, 12} | -d4 |
     {7, 11} | c3  |
     {8, 20} | -b2 |
     {9, 17} | a   |

o7 : Matrix

i8 : D = chainComplex {g1, g2, g3, g4}

o8 = image | d c a | <-- image {1, 3} | 1 0 0 0 0 0 | <-- image {3, 3}  | 1 0 0 0 0 0 | <-- image {6, 12} | 1 0 0 0 | <-- image {10, 20} | 1 |
                               {2, 0} | 0 d c a 0 0 |           {4, 12} | 0 1 0 0 0 0 |           {7, 11} | 0 1 0 0 |      
     0                         {3, 9} | 0 0 0 0 1 0 |           {5, 9}  | 0 0 1 0 0 0 |           {8, 20} | 0 0 1 0 |     4
                               {4, 8} | 0 0 0 0 0 1 |           {5, 11} | 0 0 0 1 0 0 |           {9, 17} | 0 0 0 1 |
                                                                {6, 8}  | 0 0 0 0 1 0 |      
                         1                                      {7, 17} | 0 0 0 0 0 1 |     3
                                                           
                                                          2

o8 : ChainComplex

This functor is exact.

i9 : prune HH D

o9 = 0 : cokernel {1, 2} | a c  0 b2 0  0  d3 |
                  {1, 3} | 0 -d a 0  c2 b2 0  |

     1 : 0                                     

     2 : 0                                     

     3 : 0                                     

     4 : 0                                     

o9 : GradedModule

i10 : HH_0 D == truncate({1,1}, comodule ideal"a,b2,c3,d4")

o10 = true

Ways to use this method: