Skip to content

SpanningTreeCount ​

The spanning trees: by the matrix-tree theorem, the determinant of the Laplacian with its last row and column deleted.

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt000096via LabeledGraph✓
SpanningTreeCount(graph)The spanning trees: by the matrix-tree theorem, the determinant of the Laplacian with its last row and column deleted.
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 St000096. A graph with two components has none. 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(
                                                                                        (degrees: list<integer>) => Apply(
                                                                                                                           (totals: list<integer>) => Apply(
                                                                                                                                                             (adjacency: list<list<integer>>) => Apply(
                                                                                                                                                                                                        (laplacian: list<list<integer>>) => 1 if n == 1 else Apply((a_init: list<integer>) => Fold((a: list<integer>, b) => Apply(
                                                                                                                                                                                                                                                                                                                                   (a_next: list<integer>) => a_next,
                                                                                                                                                                                                                                                                                                                                   Join(a, [Max(Sum(Map(Function((1 if Max(Sum(Map(Function((1 if w > c else 0) *
                                                                                                                                                                                                                                                                                                                                                                                            (1 if b %
                                                                                                                                                                                                                                                                                                                                                                                                  2 ^ w >=
                                                                                                                                                                                                                                                                                                                                                                                                  2 ^
                                                                                                                                                                                                                                                                                                                                                                                                  (w - 1) else 0), w), Range(1, n))), 0) %
                                                                                                                                                                                                                                                                                                                                                                       2 ==
                                                                                                                                                                                                                                                                                                                                                                       0 else -1) *
                                                                                                                                                                                                                                                                                                                                                                 laplacian[totals[b + 1]][c] *
                                                                                                                                                                                                                                                                                                                                                                 a[b -
                                                                                                                                                                                                                                                                                                                                                                   2 ^
                                                                                                                                                                                                                                                                                                                                                                   (c - 1) +
                                                                                                                                                                                                                                                                                                                                                                   1] if b %
                                                                                                                                                                                                                                                                                                                                                                     2 ^ c >=
                                                                                                                                                                                                                                                                                                                                                                     2 ^
                                                                                                                                                                                                                                                                                                                                                                     (c - 1) else 0, c), Range(1, n - 1))), -9_007_199_254_740_992.0)]),
                                                                                                                                                                                                                                                                                                                                 ), a_init, Range(1, 2 ^
                                                                                                                                                                                                                                                                                                                                                    (n - 1) -
                                                                                                                                                                                                                                                                                                                                                    1)), [1])[Length(Apply((a_init: list<integer>) => Fold((a: list<integer>, b) => Apply(
                                                                                                                                                                                                                                                                                                                                                                                                                                          (a_next: list<integer>) => a_next,
                                                                                                                                                                                                                                                                                                                                                                                                                                          Join(a, [Max(Sum(Map(Function((1 if Max(Sum(Map(Function((1 if w > c else 0) *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (1 if b %
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         2 ^ w >=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         2 ^
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (w - 1) else 0), w), Range(1, n))), 0) %
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              2 ==
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              0 else -1) *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        laplacian[totals[b + 1]][c] *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        a[b -
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          2 ^
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (c - 1) +
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          1] if b %
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2 ^ c >=
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2 ^
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (c - 1) else 0, c), Range(1, n - 1))), -9_007_199_254_740_992.0)]),
                                                                                                                                                                                                                                                                                                                                                                                                                                        ), a_init, Range(1, 2 ^
                                                                                                                                                                                                                                                                                                                                                                                                                                                           (n - 1) -
                                                                                                                                                                                                                                                                                                                                                                                                                                                           1)), [1]))],
                                                                                                                                                                                                        Map(
                                                                                                                                                                                                             Function(Map(Function(degrees[i] if i == j else 0 - adjacency[i][j], j), Range(1, n)), i),
                                                                                                                                                                                                             Range(1, n),
                                                                                                                                                                                                           ),
                                                                                                                                                                                                      ),
                                                                                                                                                             Map(
                                                                                                                                                                  Function(Map(Function(Max(Sum(Map(Function((1 if e[1] == i else 0) *
                                                                                                                                                                                                             (1 if e[2] == j else 0) +
                                                                                                                                                                                                             (1 if e[1] == j else 0) *
                                                                                                                                                                                                             (1 if e[2] == i else 0), e), edges)), 0), j), Range(1, n)), i),
                                                                                                                                                                  Range(1, n),
                                                                                                                                                                ),
                                                                                                                                                           ),
                                                                                                                           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 e[1] == v else 0) +
                                                                                                                           (1 if e[2] == v else 0), e), edges)), 0), v),
                                                                                             Range(1, n),
                                                                                           ),
                                                                                      ), _x[2]), _x[1])

Examples

Basic #

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

live ↗
InSpanningTreeCount(LabeledGraph⁡((4,[[1,2],[2,3],[2,4],[3,4]])))\mathrm{SpanningTreeCount}(\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 ([],1)

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

Known value · FindStat St000096

FindStat's value for ([],2)

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

Known value · FindStat St000096

FindStat's value for ([],3)

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

Known value · FindStat St000096

About
Examples4
CrosswalkFindStat