simplicialModule -- make a simplicial module

Usage:

simplicialModule(H1, H2, H3, d)
Inputs:
- H1, a hash table, or Complex, used to determine the modules in each degree
- H2, a hash table, used to specify the face maps
- H3, a hash table, optional, used to specify degeneracy maps if needed
- d, an integer, an integer, specifying the top degree to compute the simplicial module up to
Optional inputs:
- Degeneracy => a Boolean value, default value false, option specifying whether or not to also compute the degeneracy maps
- Base (missing documentation) => ..., default value 0,
Outputs:
- a Simplicial Module,

Description

A simplicial module is a sequence of objects (e.g. modules), connected by maps called face/degeneracy maps denoted by $d$ and $s$, respectively. These maps satisfy the simplicial identities: 1. For face maps: \[ d_j d_i = d_i d_{j-1} \text{ for } 0 \leq i < j \leq n \] 2. For face and degeneracy maps: \[ d_i s_j = s_{j-1} d_i \text{ for } i < j \] \[ d_j s_j = \text{id} \] \[ d_{j+1} s_j = \text{id} \] \[ d_k s_j = s_j d_{k-1} \text{ for } k > j+1 \] 3. For degeneracy maps: \[ s_j s_i = s_i s_{j+1} \text{ for } i \leq j \]

This constructor is the most basic constructor for building a simplicial module, and is called by all of the more user friendly constructors. It is highly recommended that the user sees simplicialModule(Complex) to quickly build simplicial modules.

i1 : S = ZZ/101[a..d]

o1 = S

o1 : PolynomialRing

i2 : moduleHash = hashTable { 0 => S^1,
                              1 => S^1++S^2,
                              2 => S^1++S^2++S^2++S^1}

                     1
o2 = HashTable{0 => S }
                     3
               1 => S
                     6
               2 => S

o2 : HashTable

i3 : faceHash = hashTable {(1,0) => matrix {{1, a, b}},
                           (1,1) => matrix {{1_S, 0, 0}},
                           (2,0) => matrix {{1, a, b, 0, 0, 0},
                                           {0, 0, 0, 1, 0, -b},
                                           {0, 0, 0, 0, 1, a}},
                           (2,1) => matrix {{1_S, 0, 0, 0, 0, 0},
                                            {0, 1, 0, 1, 0,0},
                                            {0, 0, 1, 0, 1, 0}},
                           (2,2) => matrix {{1_S, 0, 0, 0, 0, 0},
                                            {0, 1, 0, 0, 0, 0},
                                            {0, 0, 1, 0, 0, 0}}}

o3 = HashTable{(1, 0) => | 1 a b |       }
               (1, 1) => | 1 0 0 |
               (2, 0) => | 1 a b 0 0 0  |
                         | 0 0 0 1 0 -b |
                         | 0 0 0 0 1 a  |
               (2, 1) => | 1 0 0 0 0 0 |
                         | 0 1 0 1 0 0 |
                         | 0 0 1 0 1 0 |
               (2, 2) => | 1 0 0 0 0 0 |
                         | 0 1 0 0 0 0 |
                         | 0 0 1 0 0 0 |

o3 : HashTable

i4 : degenHash = hashTable {(0,0) => matrix {{1_S}, {0}, {0}},
                            (1,0) => matrix {{1_S, 0, 0},
                                             {0, 0, 0},
                                             {0, 0, 0},
                                             {0, 1, 0},
                                             {0, 0, 1},
                                             {0, 0, 0}},
                            (1,1) => matrix {{1_S, 0, 0},
                                             {0, 1, 0},
                                             {0, 0, 1},
                                             {0, 0, 0},
                                             {0, 0, 0},
                                             {0, 0, 0}}}

o4 = HashTable{(0, 0) => | 1 |    }
                         | 0 |
                         | 0 |
               (1, 0) => | 1 0 0 |
                         | 0 0 0 |
                         | 0 0 0 |
                         | 0 1 0 |
                         | 0 0 1 |
                         | 0 0 0 |
               (1, 1) => | 1 0 0 |
                         | 0 1 0 |
                         | 0 0 1 |
                         | 0 0 0 |
                         | 0 0 0 |
                         | 0 0 0 |

o4 : HashTable

i5 : T = simplicialModule(moduleHash, faceHash, degenHash, 2)

      1      3      6
o5 = S  <-- S  <-- S <-- ...
                    
     0      1      2

o5 : SimplicialModule

i6 : T.module

                     1
o6 = HashTable{0 => S }
                     3
               1 => S
                     6
               2 => S

o6 : HashTable

i7 : T.dd

               1                 3
o7 = (0, 0) : S  <------------- S  : (1, 0)
                    | 1 a b |

               1                 3
     (0, 1) : S  <------------- S  : (1, 1)
                    | 1 0 0 |

               3                        6
     (1, 0) : S  <-------------------- S  : (2, 0)
                    | 1 a b 0 0 0  |
                    | 0 0 0 1 0 -b |
                    | 0 0 0 0 1 a  |

               3                       6
     (1, 1) : S  <------------------- S  : (2, 1)
                    | 1 0 0 0 0 0 |
                    | 0 1 0 1 0 0 |
                    | 0 0 1 0 1 0 |

               3                       6
     (1, 2) : S  <------------------- S  : (2, 2)
                    | 1 0 0 0 0 0 |
                    | 0 1 0 0 0 0 |
                    | 0 0 1 0 0 0 |

o7 : SimplicialModuleMap

i8 : T.ss

               3             1
o8 = (1, 0) : S  <--------- S  : (0, 0)
                    | 1 |
                    | 0 |
                    | 0 |

               6                 3
     (2, 0) : S  <------------- S  : (1, 0)
                    | 1 0 0 |
                    | 0 0 0 |
                    | 0 0 0 |
                    | 0 1 0 |
                    | 0 0 1 |
                    | 0 0 0 |

               6                 3
     (2, 1) : S  <------------- S  : (1, 1)
                    | 1 0 0 |
                    | 0 1 0 |
                    | 0 0 1 |
                    | 0 0 0 |
                    | 0 0 0 |
                    | 0 0 0 |

o8 : SimplicialModuleMap

i9 : T' = simplicialModule(moduleHash, faceHash, 2)

      1      3      6
o9 = S  <-- S  <-- S <-- ...
                    
     0      1      2

o9 : SimplicialModule

i10 : T'.?ss

o10 = false

In the above, notice that if the user does not provide a hash table specifying the degeneracy maps, then the simplicial module is still constructed using only the data of the face maps. This feature is intentional since for the purposes of efficiency, storing the data of the degeneracy maps may slow down computations (and one can compute normalizations using only the face maps). In general, the method forgetDegeneracy allows the user to ignore the data of the degeneracy maps if needed.

In the following example, we see that one can construct simplicial modules that are not well-defined. The user should use isWellDefined(SimplicialModule) in order to check that a simplicial module is indeed well-defined.

i11 : H1 = hashTable {0 => S^1, 1 => S^1, 2 => S^1}

                      1
o11 = HashTable{0 => S }
                      1
                1 => S
                      1
                2 => S

o11 : HashTable

i12 : H2 = hashTable {(1,0) => map(S^1, S^1, 0),
                      (1,1) => map(S^1, S^1, 0),
                      (2,0) => map(S^1, S^1, 0),
                      (2,1) => map(S^1, S^1, 0),
                      (2,2) => map(S^1, S^1, 0)}

o12 = HashTable{(1, 0) => 0}
                (1, 1) => 0
                (2, 0) => 0
                (2, 1) => 0
                (2, 2) => 0

o12 : HashTable

i13 : H3 = hashTable {(0,0) => map(S^1, S^1, 0),
                      (1,0) => map(S^1, S^1, 0),
                      (1,1) => map(S^1, S^1, 0)}

o13 = HashTable{(0, 0) => 0}
                (1, 0) => 0
                (1, 1) => 0

o13 : HashTable

i14 : U = simplicialModule(H1,H2,H3,2)

       1      1      1
o14 = S  <-- S  <-- S <-- ...
                     
      0      1      2

o14 : SimplicialModule

i15 : U.dd

                1         1
o15 = (0, 0) : S  <----- S  : (1, 0)
                     0

                1         1
      (0, 1) : S  <----- S  : (1, 1)
                     0

                1         1
      (1, 0) : S  <----- S  : (2, 0)
                     0

                1         1
      (1, 1) : S  <----- S  : (2, 1)
                     0

                1         1
      (1, 2) : S  <----- S  : (2, 2)
                     0

o15 : SimplicialModuleMap

i16 : U.ss

                1         1
o16 = (1, 0) : S  <----- S  : (0, 0)
                     0

                1         1
      (2, 0) : S  <----- S  : (1, 0)
                     0

                1         1
      (2, 1) : S  <----- S  : (1, 1)
                     0

o16 : SimplicialModuleMap

i17 : isWellDefined U

o17 = false

Caveat

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

Ways to use simplicialModule:

simplicialModule(Complex,HashTable,HashTable,ZZ)
simplicialModule(Complex,HashTable,ZZ)
simplicialModule(HashTable,HashTable,HashTable,ZZ)
simplicialModule(HashTable,HashTable,ZZ)
simplicialModule(ComplexMap) (missing documentation)
simplicialModule(ComplexMap,ZZ) (missing documentation)
simplicialModule(Ideal,ZZ) -- see simplicialModule(Module,ZZ) -- make a simplicial module associated to a complex concentrated in degree 0
simplicialModule(Module,ZZ) -- make a simplicial module associated to a complex concentrated in degree 0
simplicialModule(Ring,ZZ) -- see simplicialModule(Module,ZZ) -- make a simplicial module associated to a complex concentrated in degree 0
simplicialModule(Complex) -- see The Dold-Kan Correspondence in Macaulay2 -- compute the image of a non-negatively graded complex under the Dold-Kan correspondence
simplicialModule(Complex,ZZ) -- see The Dold-Kan Correspondence in Macaulay2 -- compute the image of a non-negatively graded complex under the Dold-Kan correspondence

For the programmer

The object simplicialModule is a method function with options.

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

simplicialModule -- make a simplicial module

Description

Caveat

See also

Ways to use simplicialModule:

For the programmer