flagfVector(SimplicialComplex) -- compute the flag $f$-vector of an colored simplicial complex

Synopsis

Function: flagfVector
Usage:

f = flagfVector Delta
Inputs:
- Delta, an abstract simplicial complex,
Outputs:
- f, a hash table, where each key determines a color sets and the value is the flag f-number corresponding to that color set.

Description

A coloring of an abstract simplicial complex $\Delta$ is a labelling of its vertices with colors. The color set of a face is the set of colors of its vertices. Given a set of colors $L$, the flag $f$-number $f_L(\Delta)$ is the number of faces with color set $L$. In this package, a coloring of an abstract simplicial complex is determined by a multigrading of its ambient ring. This method function returns a hashtable whose keys are color sets (or more generally multidegrees) and whose values are the corresponding flag $f$-number.

If we color the $2$-simplex with distinct colors, each color set corresponds to a unique face.

i1 : S = QQ[a,b,c, DegreeRank => 3];

i2 : degrees S

o2 = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}

o2 : List

i3 : Δ = simplexComplex(2, S)

o3 = simplicialComplex | abc |

o3 : SimplicialComplex

i4 : flagfVector Δ

o4 = HashTable{{0, 0, 0} => 1}
               {0, 0, 1} => 1
               {0, 1, 0} => 1
               {0, 1, 1} => 1
               {1, 0, 0} => 1
               {1, 0, 1} => 1
               {1, 1, 0} => 1
               {1, 1, 1} => 1

o4 : HashTable

A coloring is proper if no two vertices in the same face have the same color. The bowtie complex has a proper $3$-coloring.

i5 : R = ZZ[a..e, Degrees => {{1,0,0},{0,1,0},{0,0,1},{1,0,0},{0,1,0}}];

i6 : Γ = simplicialComplex {a*b*c, c*d*e}

o6 = simplicialComplex | cde abc |

o6 : SimplicialComplex

i7 : assert isProper Γ

i8 : flagfVector Γ

o8 = HashTable{{0, 0, 0} => 1}
               {0, 0, 1} => 1
               {0, 1, 0} => 2
               {0, 1, 1} => 2
               {1, 0, 0} => 2
               {1, 0, 1} => 2
               {1, 1, 0} => 2
               {1, 1, 1} => 2

o8 : HashTable

We can compute $i$-th entry of the $f$-vector of $\Delta$ by taking the taking the sum of the flag $f$-numbers over color sets of size $i+1$.

i9 : fVector Γ

o9 = {1, 5, 6, 2}

o9 : List

i10 : apply(toList(-1..dim Γ), i -> (
          F := flagfVector Γ;
          sum for L in keys F list if sum L == i+1 then F#L else 0))

o10 = {1, 5, 6, 2}

o10 : List

i11 : assert(oo === fVector Γ)

The method function $\operatorname{flagfVector}$ does not check whether the multigrading on ambient ring determines a proper coloring.

The flag $f$-vector is computed as the multigraded Hilbert function of the quotient of an exterior algebra by the corresponding Stanley–Reisner ideal.

Caveat

Not every grading of the ambient polynomial ring corresponds to a coloring.

Ways to use this method: