filteredComplex(List) -- obtain a filtered complex from a list of chain complex maps or a nested list of simplicial complexes

Synopsis

Function: filteredComplex
Usage:

K = filteredComplex L
Inputs:
- L, a list,
Optional inputs:
- ReducedHomology => a Boolean value, default value true,
- Shift => an integer, default value 0,
Outputs:
- K, a filtered chain complex,

Description

We can make a filtered complex from a list of chain complex maps as follows. We first need to load the relevant packages.

i1 : needsPackage "SpectralSequences"

o1 = SpectralSequences

o1 : Package

We then make a chain complex.

i2 : R = QQ[x,y,z,w]

o2 = R

o2 : PolynomialRing

i3 : d2 = matrix(R,{{1},{0}})

o3 = | 1 |
     | 0 |

             2      1
o3 : Matrix R  <-- R

i4 : d1 = matrix(R,{{0,1}})

o4 = | 0 1 |

             1      2
o4 : Matrix R  <-- R

i5 : C = chainComplex({d1,d2})

      1      2      1
o5 = R  <-- R  <-- R
                    
     0      1      2

o5 : ChainComplex

We now make the modules of the another chain complex which we will label D.

i6 : D_2 = image matrix(R,{{1}})

o6 = image | 1 |

                             1
o6 : R-module, submodule of R

i7 : D_1 = image matrix(R,{{1,0},{0,0}})

o7 = image | 1 0 |
           | 0 0 |

                             2
o7 : R-module, submodule of R

i8 : D_0 = image matrix(R,{{1}})

o8 = image | 1 |

                             1
o8 : R-module, submodule of R

i9 : D = chainComplex({inducedMap(D_0,D_1,C.dd_1),inducedMap(D_1,D_2,C.dd_2)})

o9 = image | 1 | <-- image | 1 0 | <-- image | 1 |
                           | 0 0 |      
     0                                 2
                     1

o9 : ChainComplex

Now make a chain complex map.

i10 : d = chainComplexMap(C,D,apply(spots C, i-> inducedMap(C_i,D_i,id_C _i)))

           1
o10 = 0 : R  <--------- image | 1 | : 0
                | 1 |

           2
      1 : R  <----------- image | 1 0 | : 1
                | 1 0 |         | 0 0 |
                | 0 0 |

           1
      2 : R  <--------- image | 1 | : 2
                | 1 |

o10 : ChainComplexMap

i11 : isChainComplexMap d

o11 = true

i12 : d == chainComplexMap(C,D,{inducedMap(C_0,D_0,id_(C_0)),inducedMap(C_1,D_1,id_(C_1)),inducedMap(C_2,D_2,id_(C_2))})

o12 = true

We now make the modules of another chain complex which we will label E.

i13 : E_2 = image matrix(R,{{0}})

o13 = image 0

                              1
o13 : R-module, submodule of R

i14 : E_1 = image matrix(R,{{1,0},{0,0}})

o14 = image | 1 0 |
            | 0 0 |

                              2
o14 : R-module, submodule of R

i15 : E_0 = image matrix(R,{{1}})

o15 = image | 1 |

                              1
o15 : R-module, submodule of R

i16 : E = chainComplex({inducedMap(E_0,E_1,C.dd_1),inducedMap(E_1,E_2,C.dd_2)})

o16 = image | 1 | <-- image | 1 0 | <-- image 0
                            | 0 0 |      
      0                                 2
                      1

o16 : ChainComplex

Now make a chain complex map.

i17 : e = chainComplexMap(C,E,apply(spots C, i->inducedMap(C_i,D_i, id_C _i)))

           1
o17 = 0 : R  <--------- image | 1 | : 0
                | 1 |

           2
      1 : R  <----------- image | 1 0 | : 1
                | 1 0 |         | 0 0 |
                | 0 0 |

           1
      2 : R  <--------- image | 1 | : 2
                | 1 |

o17 : ChainComplexMap

Now make a filtered complex from a list of chain complex maps.

i18 : K = filteredComplex({d,e})

o18 = -1 : image 0 <-- image 0 <-- image 0
                                    
           0           1           2

      0 : image | 1 | <-- image | 1 0 | <-- image | 1 |
                                | 0 0 |      
          0                                 2
                          1

      1 : image | 1 | <-- image | 1 0 | <-- image | 1 |
                                | 0 0 |      
          0                                 2
                          1

           1      2      1
      2 : R  <-- R  <-- R
                         
          0      1      2

o18 : FilteredComplex

We can make a filtered complex, with a specified minimum filtration degree from a list of ChainComplexMaps by using the Shift option.

i19 : L = filteredComplex({d,e},Shift => 1)

o19 = -2 : image 0 <-- image 0 <-- image 0
                                    
           0           1           2

      -1 : image | 1 | <-- image | 1 0 | <-- image | 1 |
                                 | 0 0 |      
           0                                 2
                           1

      0 : image | 1 | <-- image | 1 0 | <-- image | 1 |
                                | 0 0 |      
          0                                 2
                          1

           1      2      1
      1 : R  <-- R  <-- R
                         
          0      1      2

o19 : FilteredComplex

i20 : M = filteredComplex({d,e},Shift => -1)

o20 = 0 : image 0 <-- image 0 <-- image 0
                                   
          0           1           2

      1 : image | 1 | <-- image | 1 0 | <-- image | 1 |
                                | 0 0 |      
          0                                 2
                          1

      2 : image | 1 | <-- image | 1 0 | <-- image | 1 |
                                | 0 0 |      
          0                                 2
                          1

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

o20 : FilteredComplex

We can make a filtered complex from a nested list of simplicial complexes as follows

i21 : D = simplicialComplex {x*y*z, x*y, y*z, w*z}

o21 = simplicialComplex | zw xyz |

o21 : SimplicialComplex

i22 : E = simplicialComplex {x*y, w}

o22 = simplicialComplex | w xy |

o22 : SimplicialComplex

i23 : F = simplicialComplex {x,w}

o23 = simplicialComplex | w x |

o23 : SimplicialComplex

i24 : K = filteredComplex{D,E,F}

o24 = -1 : image 0 <-- image 0 <-- image 0 <-- image 0
                                                
           -1          0           1           2

      0 : image | 1 | <-- image | 1 0 | <-- image 0 <-- image 0
                                | 0 0 |                  
          -1                    | 0 0 |     1           2
                                | 0 1 |
                           
                          0

      1 : image | 1 | <-- image | 1 0 0 | <-- image | 1 | <-- image 0
                                | 0 1 0 |           | 0 |      
          -1                    | 0 0 0 |           | 0 |     2
                                | 0 0 1 |           | 0 |
                                               
                          0                   1

            1       4       4       1
      2 : QQ  <-- QQ  <-- QQ  <-- QQ
                                   
          -1      0       1       2

o24 : FilteredComplex

If we want the resulting complexes to correspond to the non-reduced homology of the simplicial complexes we can do the following.

i25 : filteredComplex({D,E,F}, ReducedHomology => false)

o25 = -1 : image 0 <-- image 0 <-- image 0 <-- image 0
                                                
           -1          0           1           2

      0 : image 0 <-- image | 1 0 | <-- image 0 <-- image 0
                            | 0 0 |                  
          -1                | 0 0 |     1           2
                            | 0 1 |
                       
                      0

      1 : image 0 <-- image | 1 0 0 | <-- image | 1 | <-- image 0
                            | 0 1 0 |           | 0 |      
          -1                | 0 0 0 |           | 0 |     2
                            | 0 0 1 |           | 0 |
                                           
                      0                   1

                        4       4       1
      2 : image 0 <-- QQ  <-- QQ  <-- QQ
                                       
          -1          0       1       2

o25 : FilteredComplex

Ways to use this method: