Skip to content

ChromaticNumber ​

The fewest colors for the vertices so that adjacent vertices differ.

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt000098via LabeledGraph✓
ChromaticNumber(graph)The fewest colors for the vertices so that adjacent vertices differ.
Typed signatures
TypePackageApplies
(labeled_graph) -> numbercombinatoricsalways

Domain: Graph statistics

Details
  • Defined over LabeledGraph as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
  • Takes a LabeledGraph and nothing else — it reads values against their positions, or walks the orbits, so it needs the bijection. Applying it to a bare list is a type error, not a wrong answer.
  • FindStat's St000098. The colorings in k colors are counted as the covers of the vertices by k independent sets, Σ over the subsets S of (-1)^(n - |S|) i(S)^k with i(S) the independent sets inside S, and the number is the least k with one. The graph with no vertices gives 0.

Definition

Epsil, as the implementation runs it.

on LabeledGraph, over _x

0 if _x[1] == 0 else Apply((n: integer) => Apply((edges: list<list<integer>>) => Apply(
                                                                                        (inside: list<integer>) => Apply(
                                                                                                                          (totals: list<integer>) => Apply(
                                                                                                                                                            (within: list<integer>) => Min(Map(Function(k if Max(Sum(Map(Function((1 if (n -
                                                                                                                                                                                                                                         totals[m + 1]) %
                                                                                                                                                                                                                                        2 ==
                                                                                                                                                                                                                                        0 else -1) *
                                                                                                                                                                                                                                  within[m + 1] ^
                                                                                                                                                                                                                                  k, m), Range(0, 2 ^ n -
                                                                                                                                                                                                                                                 1))), 0) >
                                                                                                                                                                                                             0 else n, k), Range(1, n))),
                                                                                                                                                            Apply(
                                                                                                                                                                   (a_init: list<integer>) => Fold((a: list<integer>, k) => Apply(
                                                                                                                                                                                                                                   (a_next: list<integer>) => a_next,
                                                                                                                                                                                                                                   Map(Function(a[m + 1] +
                                                                                                                                                                                                                                                a[m -
                                                                                                                                                                                                                                                  2 ^
                                                                                                                                                                                                                                                  (k - 1) +
                                                                                                                                                                                                                                                  1] if m %
                                                                                                                                                                                                                                                    2 ^ k >=
                                                                                                                                                                                                                                                    2 ^
                                                                                                                                                                                                                                                    (k - 1) else a[m + 1], m), Range(0, 2 ^ n -
                                                                                                                                                                                                                                                                                 1)),
                                                                                                                                                                                                                                 ), a_init, Range(1, n)),
                                                                                                                                                                   Map(Function(1 if inside[m + 1] ==
                                                                                                                                                                                     0 else 0, m), Range(0, 2 ^ n -
                                                                                                                                                                                                           1)),
                                                                                                                                                                 ),
                                                                                                                                                          ),
                                                                                                                          Map(
                                                                                                                               Function(Max(Sum(Map(Function(1 if m %
                                                                                                                                                                  2 ^ v >=
                                                                                                                                                                  2 ^
                                                                                                                                                                  (v - 1) else 0, v), Range(1, n))), 0), m),
                                                                                                                               Range(0, 2 ^ n -
                                                                                                                                        1),
                                                                                                                             ),
                                                                                                                        ),
                                                                                        Map(
                                                                                             Function(Max(Sum(Map(Function((1 if m %
                                                                                                                                 2 ^ e[1] >=
                                                                                                                                 2 ^
                                                                                                                                 (e[1] - 1) else 0) *
                                                                                                                           (1 if m %
                                                                                                                                 2 ^ e[2] >=
                                                                                                                                 2 ^
                                                                                                                                 (e[2] - 1) else 0), e), edges)), 0), m),
                                                                                             Range(0, 2 ^ n -
                                                                                                      1),
                                                                                           ),
                                                                                      ), _x[2]), _x[1])

Examples

Basic #

the graph on 4 vertices with the edges 12, 23, 24 and 34

live ↗
InChromaticNumber(LabeledGraph⁡((4,[[1,2],[2,3],[2,4],[3,4]])))\mathrm{ChromaticNumber}(\operatorname{LabeledGraph}((4,\bigl\lbrack\bigl\lbrack1, 2\bigr\rbrack, \bigl\lbrack2, 3\bigr\rbrack, \bigl\lbrack2, 4\bigr\rbrack, \bigl\lbrack3, 4\bigr\rbrack\bigr\rbrack)))Out33
Properties #

FindStat's value for ([],0)

live ↗
InCombinatorialStat(LabeledGraph⁡((0,[])),ChromaticNumber)\mathrm{CombinatorialStat}(\operatorname{LabeledGraph}((0,\bigl\lbrack\bigr\rbrack)), \text{ChromaticNumber})Out00

Known value · FindStat St000098

FindStat's value for ([],1)

live ↗
InCombinatorialStat(LabeledGraph⁡((1,[])),ChromaticNumber)\mathrm{CombinatorialStat}(\operatorname{LabeledGraph}((1,\bigl\lbrack\bigr\rbrack)), \text{ChromaticNumber})Out11

Known value · FindStat St000098

FindStat's value for ([],2)

live ↗
InCombinatorialStat(LabeledGraph⁡((2,[])),ChromaticNumber)\mathrm{CombinatorialStat}(\operatorname{LabeledGraph}((2,\bigl\lbrack\bigr\rbrack)), \text{ChromaticNumber})Out11

Known value · FindStat St000098

About
Examples4
CrosswalkFindStat