Skip to content

SzegedIndex ​

The sum over the edges of the vertices nearer one end times those nearer the other.

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt000263via LabeledGraph✓
SzegedIndex(graph)The sum over the edges of the vertices nearer one end times those nearer the other.
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 St000263. A vertex in another component is as far from both ends, so is in neither count. 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(
                                                                                                                                   (distances: list<list<integer>>) => Max(Sum(Map(Function(Max(Sum(Map(Function(1 if distances[e[1]][w] < distances[e[2]][w] else 0, w), Range(1, n))), 0) *
                                                                                                                                                                                            Max(Sum(Map(Function(1 if distances[e[2]][w] < distances[e[1]][w] else 0, w), Range(1, n))), 0), e), edges)), 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 ↗
InSzegedIndex(LabeledGraph⁡((4,[[1,2],[2,3],[2,4],[3,4]])))\mathrm{SzegedIndex}(\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)))Out88
Properties #

FindStat's value for ([],1)

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

Known value · FindStat St000263

FindStat's value for ([],2)

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

Known value · FindStat St000263

FindStat's value for ([],3)

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

Known value · FindStat St000263

About
Examples4
CrosswalkFindStat