faces(SimplicialComplex) -- get the list of faces for an abstract simplicial complex

Synopsis

Function: faces
Usage:

faces Delta
Inputs:
- Delta, an abstract simplicial complex,
Outputs:
- a hash table,

Description

In this package, an abstract simplicial complex $\Delta$ is identified with a squarefree monomial ideal in a polynomial ring. The vertices of $\Delta$ correspond to a subset of the variables in the polynomial ring, and each face is identified as the product of the variables corresponding to the vertices of that face. This method function returns a HashTable whose keys are the integers from $-1$ to $\operatorname{dim} \Delta$ and the value of the key $i$ is the list containing the monomials corresponding to the $i$-dimensional faces of $\Delta$.

The faces of the simplex correspond to all subsets of the underlying vertex set.

i1 : S = QQ[x_0..x_3];

i2 : Δ = simplexComplex(3, S)

o2 = simplicialComplex | x_0x_1x_2x_3 |

o2 : SimplicialComplex

i3 : faces Δ

o3 = HashTable{-1 => {1}                                }
               0 => {x , x , x , x }
                      0   1   2   3
               1 => {x x , x x , x x , x x , x x , x x }
                      0 1   0 2   0 3   1 2   1 3   2 3
               2 => {x x x , x x x , x x x , x x x }
                      0 1 2   0 1 3   0 2 3   1 2 3
               3 => {x x x x }
                      0 1 2 3

o3 : HashTable

i4 : dim Δ

o4 = 3

i5 : subsets vertices Δ

o5 = {{}, {x }, {x }, {x , x }, {x }, {x , x }, {x , x }, {x , x , x }, {x },
            0     1     0   1     2     0   2     1   2     0   1   2     3  
     ------------------------------------------------------------------------
     {x , x }, {x , x }, {x , x , x }, {x , x }, {x , x , x }, {x , x , x },
       0   3     1   3     0   1   3     2   3     0   2   3     1   2   3  
     ------------------------------------------------------------------------
     {x , x , x , x }}
       0   1   2   3

o5 : List

i6 : assert(faces Δ === hashTable for i from -1 to 3 list
         i => first entries sub(matrix{rsort subsets(vertices Δ, i+1)/product}, S))

The faces of the Bartnette sphere are a proper subset of the $7$-simplex.

i7 : R = ZZ[a..h];

i8 : Γ = bartnetteSphereComplex R;

i9 : matrix {facets Γ}

o9 = | defh befh cdfh bcfh adeh abeh acdh abch defg cefg adfg acfg bdeg bceg
     ------------------------------------------------------------------------
     abdg abcg bcef acdf abde |

             1      19
o9 : Matrix R  <-- R

i10 : faces Γ

o10 = HashTable{-1 => {1}                                                                                                                                                                                                                                                                      }
                0 => {a, b, c, d, e, f, g, h}
                1 => {a*b, a*c, a*d, a*e, a*f, a*g, a*h, b*c, b*d, b*e, b*f, b*g, b*h, c*d, c*e, c*f, c*g, c*h, d*e, d*f, d*g, d*h, e*f, e*g, e*h, f*g, f*h}
                2 => {a*b*c, a*b*d, a*b*e, a*b*g, a*b*h, a*c*d, a*c*f, a*c*g, a*c*h, a*d*e, a*d*f, a*d*g, a*d*h, a*e*h, a*f*g, b*c*e, b*c*f, b*c*g, b*c*h, b*d*e, b*d*g, b*e*f, b*e*g, b*e*h, b*f*h, c*d*f, c*d*h, c*e*f, c*e*g, c*f*g, c*f*h, d*e*f, d*e*g, d*e*h, d*f*g, d*f*h, e*f*g, e*f*h}
                3 => {a*b*c*g, a*b*c*h, a*b*d*e, a*b*d*g, a*b*e*h, a*c*d*f, a*c*d*h, a*c*f*g, a*d*e*h, a*d*f*g, b*c*e*f, b*c*e*g, b*c*f*h, b*d*e*g, b*e*f*h, c*d*f*h, c*e*f*g, d*e*f*g, d*e*f*h}

o10 : HashTable

i11 : monomialIdeal Γ

o11 = monomialIdeal (b*c*d, a*c*e, c*d*e, a*b*f, b*d*f, a*e*f, c*d*g, a*e*g,
      -----------------------------------------------------------------------
      b*f*g, b*d*h, c*e*h, a*f*h, g*h)

o11 : MonomialIdeal of R

There are two "trivial" simplicial complexes: the irrelevant complex has the empty set as a facet whereas the void complex has no facets.

i12 : irrelevant = simplicialComplex monomialIdeal gens S

o12 = simplicialComplex | 1 |

o12 : SimplicialComplex

i13 : faces irrelevant

o13 = HashTable{-1 => {1}}

o13 : HashTable

i14 : assert(faces irrelevant === hashTable{-1 => {1_S}})

i15 : void = simplicialComplex monomialIdeal 1_S

o15 = simplicialComplex 0

o15 : SimplicialComplex

i16 : faces void

o16 = HashTable{}

o16 : HashTable

i17 : assert(faces void === hashTable{})

Ways to use this method: