simplicialModule(Module,ZZ) -- make a simplicial module associated to a complex concentrated in degree 0

Function: simplicialModule
Usage:

simplicialModule(M, d)
Inputs:
- M, a module, or Ideal, or Ring.
- d, an integer, top degree to compute the simplicial module up to
Optional inputs:
- Base (missing documentation) => ..., default value 0,
- Degeneracy => ..., default value false, whether to compute degeneracy maps
Outputs:
- a Simplicial Module, returns the complex whose 0-th component is M.

Description

In contrast to simplicialModule(HashTable,HashTable,HashTable,ZZ) or simplicialModule(Complex,ZZ), this constructor provides a convenient method to construct a simplicial module from a single module/ring/ideal.

We illustrate this with a free module.

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

o1 = S

o1 : PolynomialRing

i2 : C0 = simplicialModule( S^2, 6, Degeneracy => true)

      2      2      2      2      2      2      2
o2 = S  <-- S  <-- S  <-- S  <-- S  <-- S  <-- S <-- ...
                                                
     0      1      2      3      4      5      6

o2 : SimplicialModule

i3 : f = dd^C0

               2               2
o3 = (0, 0) : S  <----------- S  : (1, 0)
                    | 1 0 |
                    | 0 1 |

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

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

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

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

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

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

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

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

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

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

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

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

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

               2               2
     (4, 0) : S  <----------- S  : (5, 0)
                    | 1 0 |
                    | 0 1 |

               2               2
     (4, 1) : S  <----------- S  : (5, 1)
                    | 1 0 |
                    | 0 1 |

               2               2
     (4, 2) : S  <----------- S  : (5, 2)
                    | 1 0 |
                    | 0 1 |

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

               2               2
     (4, 4) : S  <----------- S  : (5, 4)
                    | 1 0 |
                    | 0 1 |

               2               2
     (4, 5) : S  <----------- S  : (5, 5)
                    | 1 0 |
                    | 0 1 |

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

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

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

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

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

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

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

o3 : SimplicialModuleMap

i4 : source f, target f

       2      2      2      2      2      2      2          2      2      2
o4 = (S  <-- S  <-- S  <-- S  <-- S  <-- S  <-- S <-- ..., S  <-- S  <-- S 
                                                                           
      0      1      2      3      4      5      6          0      1      2 
     ------------------------------------------------------------------------
          2      2      2      2
     <-- S  <-- S  <-- S  <-- S <-- ...)
                               
         3      4      5      6

o4 : Sequence

i5 : f == 0

o5 = false

i6 : isWellDefined C0

o6 = true

i7 : C0 == 0

o7 = false

i8 : topDegree C0

o8 = 6

i9 : C1 = simplicialModule(complex(S^2, Base=>3), 6, Degeneracy => true)

                        2      8      20      40
o9 = 0 <-- 0 <-- 0 <-- S  <-- S  <-- S   <-- S  <-- ...
                                              
     0     1     2     3      4      5       6

o9 : SimplicialModule

i10 : C1_3

       2
o10 = S

o10 : S-module, free

i11 : C1_0

o11 = 0

o11 : S-module

A ring or an ideal will be converted to a module first.

i12 : C2 = simplicialModule( S, 5, Degeneracy => true)

       1      1      1      1      1      1
o12 = S  <-- S  <-- S  <-- S  <-- S  <-- S <-- ...
                                          
      0      1      2      3      4      5

o12 : SimplicialModule

i13 : I = ideal(a^2-b, c^3)

              2       3
o13 = ideal (a  - b, c )

o13 : Ideal of S

i14 : C3 = simplicialModule( I, 7, Degeneracy => true)

o14 = image | a2-b c3 | <-- image | a2-b c3 | <-- image | a2-b c3 | <-- image | a2-b c3 | <-- image | a2-b c3 | <-- image | a2-b c3 | <-- image | a2-b c3 | <-- image | a2-b c3 |<-- ...
                                                                                                                                                                 
      0                     1                     2                     3                     4                     5                     6                     7

o14 : SimplicialModule

i15 : C4 = simplicialModule( (S/I), 8, Degeneracy => true)

      /      S     \1     /      S     \1     /      S     \1     /      S     \1     /      S     \1     /      S     \1     /      S     \1     /      S     \1     /      S     \1
o15 = |------------|  <-- |------------|  <-- |------------|  <-- |------------|  <-- |------------|  <-- |------------|  <-- |------------|  <-- |------------|  <-- |------------| <-- ...
      |  2       3 |      |  2       3 |      |  2       3 |      |  2       3 |      |  2       3 |      |  2       3 |      |  2       3 |      |  2       3 |      |  2       3 |
      \(a  - b, c )/      \(a  - b, c )/      \(a  - b, c )/      \(a  - b, c )/      \(a  - b, c )/      \(a  - b, c )/      \(a  - b, c )/      \(a  - b, c )/      \(a  - b, c )/
                                                                                                                                                                       
      0                   1                   2                   3                   4                   5                   6                   7                   8

o15 : SimplicialModule

i16 : (ring C3, ring C4)

                S
o16 = (S, ------------)
            2       3
          (a  - b, c )

o16 : Sequence

The zero simplicial module over a ring S is most conveniently created by giving the zero module.

i17 : C5 = simplicialModule(S^0, 8, Degeneracy => true)

o17 = 0 <-- 0 <-- 0 <-- 0 <-- 0 <-- 0 <-- 0 <-- 0 <-- 0<-- ...
                                                       
      0     1     2     3     4     5     6     7     8

o17 : SimplicialModule

i18 : C5 == 0

o18 = true

i19 : dd^C5 == 0

o19 = true

i20 : ss^C5 == 0

o20 = true

i21 : C5_0

o21 = 0

o21 : S-module

Ways to use this method:

simplicialModule(Ideal,ZZ)
simplicialModule(Module,ZZ) -- make a simplicial module associated to a complex concentrated in degree 0
simplicialModule(Ring,ZZ)

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

simplicialModule(Module,ZZ) -- make a simplicial module associated to a complex concentrated in degree 0

Description

See also

Ways to use this method: