map(Complex,Complex,HashTable) -- make a map of chain complexes

Synopsis

Function: map
Usage:

f = map(D, C, H)
Inputs:
- C, a complex,
- D, a complex,
- H, a hash table, whose keys are integers, and whose values are the maps between the corresponding terms
Optional inputs:
- Degree => an integer, default value null, the degree of the resulting map
- DegreeLift => ..., default value null, unused
- DegreeMap => ..., default value null, unused
Outputs:
- f, a map of complexes,

Description

A map of complexes $f : C \rightarrow D$ of degree $d$ is a sequence of maps $f_i : C_i \rightarrow D_{d+i}$. No relationship between the maps $f_i$ and and the differentials of either $C$ or $D$ is assumed.

We construct a map of chain complexes by specifying the individual maps between the terms.

i1 : R = ZZ/101[a,b,c];

i2 : C = freeResolution coker matrix{{a^2-b^2,b^3-c^3,c^4}}

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

o2 : Complex

i3 : D = freeResolution coker vars R

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

o3 : Complex

i4 : H = hashTable { 0 => map(D_0, C_0, 1),
         1 => map(D_1, C_1, {{a, 0, 0}, {-b, b^2, 0}, {0, -c^2, c^3}}),
         2 => map(D_2, C_2, {{a*b^2, 0, 0}, {-a*c^2, a*c^3, 0}, {b*c^2, -b*c^3, b^2*c^3}}),
         3 => map(D_3, C_3, {{a*b^2*c^3}})
         }

o4 = HashTable{0 => | 1 |                 }
               1 => {1} | a  0   0  |
                    {1} | -b b2  0  |
                    {1} | 0  -c2 c3 |
               2 => {2} | ab2  0    0    |
                    {2} | -ac2 ac3  0    |
                    {2} | bc2  -bc3 b2c3 |
               3 => {3} | ab2c3 |

o4 : HashTable

i5 : f = map(D, C, H)

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

          3                         3
     1 : R  <--------------------- R  : 1
               {1} | a  0   0  |
               {1} | -b b2  0  |
               {1} | 0  -c2 c3 |

          3                              3
     2 : R  <-------------------------- R  : 2
               {2} | ab2  0    0    |
               {2} | -ac2 ac3  0    |
               {2} | bc2  -bc3 b2c3 |

          1                     1
     3 : R  <----------------- R  : 3
               {3} | ab2c3 |

o5 : ComplexMap

i6 : assert isWellDefined f

i7 : assert isHomogeneous f

i8 : assert(degree f == 0)

i9 : assert isComplexMorphism f

The keys in the hash table index the terms in the source of the map. If a key is missing, that map is taken to be the zero map. We illustrate by constructing a map of chain complexes having nonzero degree, and omitting one key in the hash table.

i10 : E = D[-3]

       1      3      3      1
o10 = R  <-- R  <-- R  <-- R
                            
      3      4      5      6

o10 : Complex

i11 : H = hashTable { 0 => map(E_3, C_0, 1),
          1 => map(E_4, C_1, {{a, 0, 0}, {-b, b^2, 0}, {0, -c^2, c^3}}),
          3 => map(E_6, C_3, {{a*b^2*c^3}})
          }

o11 = HashTable{0 => | 1 |            }
                1 => {1} | a  0   0  |
                     {1} | -b b2  0  |
                     {1} | 0  -c2 c3 |
                3 => {3} | ab2c3 |

o11 : HashTable

i12 : g = map(E, C, H, Degree => 3)

           1             1
o12 = 3 : R  <--------- R  : 0
                | 1 |

           3                         3
      4 : R  <--------------------- R  : 1
                {1} | a  0   0  |
                {1} | -b b2  0  |
                {1} | 0  -c2 c3 |

           1                     1
      6 : R  <----------------- R  : 3
                {3} | ab2c3 |

o12 : ComplexMap

i13 : g_2

o13 = 0

              3      3
o13 : Matrix R  <-- R

i14 : assert(g_1 == f_1)

i15 : assert(g != f)

i16 : assert isWellDefined g

i17 : assert isHomogeneous g

i18 : assert(degree g == 3)

i19 : assert not isComplexMorphism g

i20 : assert not isCommutative g

i21 : assert(source g == C)

i22 : assert(target g == E)

This is the primary constructor used by all of the more user friendly methods for constructing a chain complex.

Caveat

This constructor minimizes computation and does very little error checking. To verify that a complex is well constructed, use isWellDefined(ComplexMap).

Ways to use this method: