boundaryMap(ZZ,SimplicialComplex) -- make a boundary map between the oriented faces of an abstract simplicial complex

Synopsis

Function: boundaryMap
Usage:

boundaryMap(i, Delta)
Inputs:
- i, an integer, specifying the dimension of faces in the source of the map
- Delta, an abstract simplicial complex,
Optional inputs:
- Labels => a list, default value {}, of monomials in a polynomial ring, one for each vertex of $\Delta$
Outputs:
- a matrix, that determines a map from $i$-faces to $i-1$-faces of $\Delta$

Description

Up to sign, the boundary maps form the differential in the chain complex associated to an abstract simplicial complex. The columns of the output matrix are indexed by the $i$-faces of the abstract simplicial complex $\Delta$ and the rows are indexed by the $(i-1)$-faces. The order of these indices is obtained from the faces method which is implicitly determined by the monomial order on the underlying ring. The matrix is defined over the coefficient ring of $\Delta$ and its entries in this matrix are $-1$, $0$,or $1$ depending on whether the row index is an oriented face of the column index. The orientation of $\Delta$ is induced by the ordering of the variables in its underlying ring.

Working over the integers, we have the boundary maps for the standard $3$-simplex.

i1 : R = ZZ[a..d];

i2 : Δ = simplicialComplex {a*b*c*d}

o2 = simplicialComplex | abcd |

o2 : SimplicialComplex

i3 : boundaryMap(0, Δ)

o3 = | 1 1 1 1 |

              1       4
o3 : Matrix ZZ  <-- ZZ

i4 : boundaryMap(1, Δ)

o4 = | -1 -1 -1 0  0  0  |
     | 1  0  0  -1 -1 0  |
     | 0  1  0  1  0  -1 |
     | 0  0  1  0  1  1  |

              4       6
o4 : Matrix ZZ  <-- ZZ

i5 : boundaryMap(2, Δ)

o5 = | 1  1  0  0  |
     | -1 0  1  0  |
     | 0  -1 -1 0  |
     | 1  0  0  1  |
     | 0  1  0  -1 |
     | 0  0  1  1  |

              6       4
o5 : Matrix ZZ  <-- ZZ

i6 : boundaryMap(3, Δ)

o6 = | -1 |
     | 1  |
     | -1 |
     | 1  |

              4       1
o6 : Matrix ZZ  <-- ZZ

i7 : fVector Δ

o7 = {1, 4, 6, 4, 1}

o7 : List

i8 : C = chainComplex Δ

       1       4       6       4       1
o8 = ZZ  <-- ZZ  <-- ZZ  <-- ZZ  <-- ZZ
                                      
     -1      0       1       2       3

o8 : ChainComplex

i9 : assert all(4, i -> C.dd_i == - boundaryMap(i, Δ))

The boundary maps may depend on the coefficient ring.

i10 : R' = ZZ/2[a..d];

i11 : Δ' = sub(Δ, R');

i12 : boundaryMap(0, Δ')

o12 = | 1 1 1 1 |

              ZZ 1      ZZ 4
o12 : Matrix (--)  <-- (--)
               2         2

i13 : boundaryMap(1, Δ')

o13 = | 1 1 1 0 0 0 |
      | 1 0 0 1 1 0 |
      | 0 1 0 1 0 1 |
      | 0 0 1 0 1 1 |

              ZZ 4      ZZ 6
o13 : Matrix (--)  <-- (--)
               2         2

i14 : boundaryMap(2, Δ')

o14 = | 1 1 0 0 |
      | 1 0 1 0 |
      | 0 1 1 0 |
      | 1 0 0 1 |
      | 0 1 0 1 |
      | 0 0 1 1 |

              ZZ 6      ZZ 4
o14 : Matrix (--)  <-- (--)
               2         2

i15 : boundaryMap(3, Δ')

o15 = | 1 |
      | 1 |
      | 1 |
      | 1 |

              ZZ 4      ZZ 1
o15 : Matrix (--)  <-- (--)
               2         2

When the optional argument Labels is given a list of monomials, corresponding to the vertices of $\Delta$, this method returns the differential in a chain complex of free modules. Each face, or basis vector, is labelled by the least common multiple of the labels on its vertices. In other words, the chain complex associated to a labelled simplicial complex is the homogenization of the canonical chain complex associated to $\Delta$; see Chapter 4 in Miller-Sturmfels' Combinatorial Commutative Algebra or Section 55 in Irena Peeva's Graded Syzygies.

Labelling the vertices in the standard $3$-simplex by its unique monomial generators, we obtain the differential in the Taylor resolution of a monomial ideal.

i16 : S = ZZ/101[x_0, x_1];

i17 : M = monomialIdeal(x_1^3, x_0*x_1^2, x_0^2*x_1, x_0^3);

o17 : MonomialIdeal of S

i18 : boundaryMap(0, Δ,  Labels => sort M_*)

o18 = | x_1^3 x_0x_1^2 x_0^2x_1 x_0^3 |

              1      4
o18 : Matrix S  <-- S

i19 : boundaryMap(1, Δ,  Labels => sort M_*)

o19 = {3} | -x_0 -x_0^2 -x_0^3 0    0      0    |
      {3} | x_1  0      0      -x_0 -x_0^2 0    |
      {3} | 0    x_1^2  0      x_1  0      -x_0 |
      {3} | 0    0      x_1^3  0    x_1^2  x_1  |

              4      6
o19 : Matrix S  <-- S

i20 : boundaryMap(2, Δ,  Labels => sort M_*)

o20 = {4} | x_0 x_0^2 0     0   |
      {5} | -1  0     x_0   0   |
      {6} | 0   -1    -1    0   |
      {4} | x_1 0     0     x_0 |
      {5} | 0   x_1   0     -1  |
      {4} | 0   0     x_1^2 x_1 |

              6      4
o20 : Matrix S  <-- S

i21 : boundaryMap(3, Δ,  Labels => sort M_*)

o21 = {5} | -x_0 |
      {6} | 1    |
      {6} | -1   |
      {5} | x_1  |

              4      1
o21 : Matrix S  <-- S

i22 : T = taylorResolution M

       1      4      6      4      1
o22 = S  <-- S  <-- S  <-- S  <-- S
                                   
      0      1      2      3      4

o22 : ChainComplex

i23 : T.dd

           1                                         4
o23 = 0 : S  <------------------------------------- S  : 1
                | x_1^3 x_0x_1^2 x_0^2x_1 x_0^3 |

           4                                                   6
      1 : S  <----------------------------------------------- S  : 2
                {3} | -x_0 -x_0^2 -x_0^3 0    0      0    |
                {3} | x_1  0      0      -x_0 -x_0^2 0    |
                {3} | 0    x_1^2  0      x_1  0      -x_0 |
                {3} | 0    0      x_1^3  0    x_1^2  x_1  |

           6                                   4
      2 : S  <------------------------------- S  : 3
                {4} | x_0 x_0^2 0     0   |
                {5} | -1  0     x_0   0   |
                {6} | 0   -1    -1    0   |
                {4} | x_1 0     0     x_0 |
                {5} | 0   x_1   0     -1  |
                {4} | 0   0     x_1^2 x_1 |

           4                    1
      3 : S  <---------------- S  : 4
                {5} | -x_0 |
                {6} | 1    |
                {6} | -1   |
                {5} | x_1  |

o23 : ChainComplexMap

i24 : assert all(4, i -> T.dd_(i+1) == boundaryMap(i, Δ,  Labels => sort M_*))

Ways to use this method: