Macaulay2 » Documentation
Packages » SpectralSequences :: filteredComplex(List)
next | previous | forward | backward | up | index | toc

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

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 = complex ({d1,d2})

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

o5 : Complex

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

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

o6 = image | 1 |

                             1
o6 : R-module, submodule of R
 
i7 : D1 = image matrix(R,{{1,0},{0,0}})

o7 = image | 1 0 |
           | 0 0 |

                             2
o7 : R-module, submodule of R
 
i8 : D0 = image matrix(R,{{1}})

o8 = image | 1 |

                             1
o8 : R-module, submodule of R
 
i9 : D = complex({inducedMap(D0,D1,C.dd_1),inducedMap(D1,D2,C.dd_2)})

o9 = D2 <-- D1 <-- D2
                    
     0      1      2

o9 : Complex

Now make a chain complex map.

i10 : d = map(C,D,{inducedMap(C_0,D0,id_(C_0)),inducedMap(C_1,D1,id_(C_1)),inducedMap(C_2,D2,id_(C_2))})

           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 : ComplexMap
 
i11 : isWellDefined d

o11 = true

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

i12 : E2 = image matrix(R,{{0}})

o12 = image 0

                              1
o12 : R-module, submodule of R
 
i13 : E1 = image matrix(R,{{1,0},{0,0}})

o13 = image | 1 0 |
            | 0 0 |

                              2
o13 : R-module, submodule of R
 
i14 : E0 = image matrix(R,{{1}})

o14 = image | 1 |

                              1
o14 : R-module, submodule of R
 
i15 : E = complex ({inducedMap(E0,E1,C.dd_1),inducedMap(E1,E2,C.dd_2)})

o15 = D2 <-- D1 <-- E2
                     
      0      1      2

o15 : Complex

Now make a chain complex map.

i16 : e = map(C,E,{inducedMap(C_0,E0,id_(C_0)),inducedMap(C_1,E1,id_(C_1)),inducedMap(C_2,E_2,id_(C_2))})

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

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

o16 : ComplexMap
 
i17 : isWellDefined e

o17 = true

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

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

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

      0 : D2 <-- D1 <-- E2
                         
          0      1      2

      1 : D2 <-- D1 <-- D2
                         
          0      1      2

           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 ComplexMaps by using the Shift option.

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

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

      -1 : D2 <-- D1 <-- E2
                          
           0      1      2

      0 : D2 <-- D1 <-- D2
                         
          0      1      2

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

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

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

      1 : D2 <-- D1 <-- E2
                         
          0      1      2

      2 : D2 <-- D1 <-- D2
                         
          0      1      2

           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
                                    
           0           1           2

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

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

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

o25 : FilteredComplex

See also

Ways to use this method:

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

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