Skip to content

CutVertexCount ​

The vertices whose deletion leaves more components.

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt000552via LabeledGraph✓
CutVertexCount(graph)The vertices whose deletion leaves more components.
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 St000552. The deleted vertex stays as an isolated one, a component of its own. 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(
                                                                                        (adjacency: list<list<integer>>) => Apply(
                                                                                                                                   (components: integer) => Max(Sum(Map(Function(1 if Apply(
                                                                                                                                                                                             (reach: list<list<integer>>) => Max(Sum(Map(Function(1 if Max(Sum(Map(Function((1 if reach[u][v] < n else 0) if u < v else 0, u), Range(1, n))), 0) ==
                                                                                                                                                                                                                                                       0 else 0, v), Range(1, n))), 0),
                                                                                                                                                                                             Apply(
                                                                                                                                                                                                    (matrix: list<list<integer>>) => Apply(
                                                                                                                                                                                                                                            (a_init: list<list<integer>>) => Fold((a: list<list<integer>>, k) => Apply(
                                                                                                                                                                                                                                                                                                                        (a_next: list<list<integer>>) => a_next,
                                                                                                                                                                                                                                                                                                                        Map(Function(Map(Function(Min(a[i][j], a[i][k] + a[k][j]), j), Range(1, n)), i), Range(1, n)),
                                                                                                                                                                                                                                                                                                                      ), a_init, Range(1, n)),
                                                                                                                                                                                                                                            Map(Function(Map(Function(0 if i == j else 1 if matrix[i][j] == 1 else 2n, j), Range(1, n)), i), Range(1, n)),
                                                                                                                                                                                                                                          ),
                                                                                                                                                                                                    Map(Function(Map(Function(adjacency[i][j] *
                                                                                                                                                                                                                              (1 if (1 if i == v else 0) ==
                                                                                                                                                                                                                                    0 else 0) *
                                                                                                                                                                                                                              (1 if (1 if j == v else 0) ==
                                                                                                                                                                                                                                    0 else 0), j), Range(1, n)), i), Range(1, n)),
                                                                                                                                                                                                  ),
                                                                                                                                                                                           ) >
                                                                                                                                                                                      components + 1 else 0, v), Range(1, n))), 0),
                                                                                                                                   Apply(
                                                                                                                                          (reach: list<list<integer>>) => Max(Sum(Map(Function(1 if Max(Sum(Map(Function((1 if reach[u][v] < n else 0) if u < v else 0, u), Range(1, n))), 0) ==
                                                                                                                                                                                                    0 else 0, v), Range(1, n))), 0),
                                                                                                                                          Apply((matrix: list<list<integer>>) => Apply(
                                                                                                                                                                                        (a_init: list<list<integer>>) => Fold((a: list<list<integer>>, k) => Apply(
                                                                                                                                                                                                                                                                    (a_next: list<list<integer>>) => a_next,
                                                                                                                                                                                                                                                                    Map(Function(Map(Function(Min(a[i][j], a[i][k] + a[k][j]), j), Range(1, n)), i), Range(1, n)),
                                                                                                                                                                                                                                                                  ), a_init, Range(1, n)),
                                                                                                                                                                                        Map(
                                                                                                                                                                                             Function(Map(Function(0 if i == j else 1 if matrix[i][j] == 1 else 2n, j), Range(1, n)), i),
                                                                                                                                                                                             Range(1, n),
                                                                                                                                                                                           ),
                                                                                                                                                                                      ), adjacency),
                                                                                                                                        ),
                                                                                                                                 ),
                                                                                        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)),
                                                                                      ), _x[2]), _x[1])

Examples

Basic #

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

live ↗
InCutVertexCount(LabeledGraph⁡((4,[[1,2],[2,3],[2,4],[3,4]])))\mathrm{CutVertexCount}(\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)))Out11
Properties #

FindStat's value for ([],1)

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

Known value · FindStat St000552

FindStat's value for ([],2)

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

Known value · FindStat St000552

FindStat's value for ([],3)

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

Known value · FindStat St000552

About
Examples4
CrosswalkFindStat