Skip to content

LabeledGraphs ​

A name from the enumeratio catalogue with no kernel of its own yet; this page carries its crosswalk only.

Simple undirected graphs on the labeled vertex set [n].

LabeledGraphs(...)Simple undirected graphs on the labeled vertex set [n].
Typed signatures
TypePackageApplies
(integer<0..>) -> indexed_collection<labeled_graph>combinatoricsalways

Domain: Combinatorics

Definition

Epsil, as the implementation runs it.

count(_n)

2 ^ (Binomial(_n, 2) if 0 <= 2 && 2 <= _n else 0)

unrank(_n, _r)

Map(
     Function(Apply((gu_k: integer) => Apply(
                                              (gu_u: integer) => Apply(
                                                                        (gu_v: integer) => [gu_v, gu_u] if False else [gu_u, gu_v],
                                                                        gu_k -
                                                                        ((Binomial(_n, 2) if 0 <= 2 &&
                                                                                             2 <= _n else 0) -
                                                                         (Binomial(_n - gu_u +
                                                                                   1, 2) if 0 <= 2 &&
                                                                                           2 <=
                                                                                           _n - gu_u +
                                                                                           1 else 0)) + gu_u,
                                                                      ),
                                              _tables[gu_k],
                                            ), gk), gk),
     Filter(
             Range(1, Binomial(_n, 2) if 0 <= 2 && 2 <= _n else 0, 1),
             Function((_r - _r % 2 ^ (gb - 1)) / 2 ^ (gb - 1) % 2 == 1, gb),
           ),
   )

rank(_n, _x)

Fold(Function(
               ga + 2 ^ ((Binomial(_n, 2) if 0 <= 2 && 2 <= _n else 0) -
                         (Binomial(_n - Min(_x[gj][1], _x[gj][2]) + 1, 2) if 0 <=
                                                                             2 &&
                                                                             2 <=
                                                                             _n -
                                                                             Min(_x[gj][1], _x[gj][2]) +
                                                                             1 else 0) + (Max(_x[gj][1], _x[gj][2]) - Min(
                                                              _x[gj][1],
                                                              _x[gj][2],
                                                            )) - 1),
               ga,
               gj,
             ), 0, Range(1, Length(_x), 1))

valid(_n, _x)

Fold(Function(ok_wb && 1 <= _x[wb][1] && _x[wb][1] <= _n && 1 <= _x[wb][2] &&
                       _x[wb][2] <= _n && _x[wb][1] != _x[wb][2], ok_wb, wb), True, Range(1, Length(_x), 1)) && Fold(
                                                                             Function(ok_wj &&
                                                                                      Fold(
                                                                                            Function(ok_wi &&
                                                                                                     (Binomial(_n, 2) if 0 <= 2 &&
                                                                                                                         2 <= _n else 0) -
                                                                                                     (Binomial(_n -
                                                                                                               Min(_x[wi][1], _x[wi][2]) +
                                                                                                               1, 2) if 0 <= 2 &&
                                                                                                                       2 <=
                                                                                                                       _n -
                                                                                                                       Min(_x[wi][1], _x[wi][2]) +
                                                                                                                       1 else 0) +
                                                                                                     (Max(_x[wi][1], _x[wi][2]) -
                                                                                                      Min(_x[wi][1], _x[wi][2])) !=
                                                                                                     (Binomial(_n, 2) if 0 <= 2 &&
                                                                                                                         2 <= _n else 0) -
                                                                                                     (Binomial(_n -
                                                                                                               Min(_x[wj][1], _x[wj][2]) +
                                                                                                               1, 2) if 0 <= 2 &&
                                                                                                                       2 <=
                                                                                                                       _n -
                                                                                                                       Min(_x[wj][1], _x[wj][2]) +
                                                                                                                       1 else 0) +
                                                                                                     (Max(_x[wj][1], _x[wj][2]) -
                                                                                                      Min(_x[wj][1], _x[wj][2])), ok_wi, wi),
                                                                                            True,
                                                                                            Range(1, wj - 1, 1),
                                                                                          ), ok_wj, wj),
                                                                             True,
                                                                             Range(1, Length(_x), 1),
                                                                           ) if Fold(
                                                                                     Function(ok_wp &&
                                                                                              Length(_x[wp]) == 2, ok_wp, wp),
                                                                                     True,
                                                                                     Range(1, Length(_x), 1),
                                                                                   ) else False

tables(_n)

Fold(
      Function(Join(et, Map(Function(eu, ez), Range(1, _n - eu, 1))), et, eu),
      [],
      Range(1, _n - 1, 1),
    )

Statistics

On LabeledGraph, called as CombinatorialStat(x, "Name").

Maps

Into and out of LabeledGraph, called as CombinatorialMap(x, "Name"). Properties are the laws we state and what FindStat records.

28 more in FindStat, not implemented here
  • Mp00011BinaryTree → LabeledGraphGraded mapto graph
  • Mp00037LabeledGraph → IntegerPartitionSurjectionGraded mapto partition of connected components
  • Mp00046OrderedTree → LabeledGraphGraded mapto graph
  • Mp00074Posets → LabeledGraphGraded mapto graph
  • Mp00111LabeledGraph → LabeledGraphBijectionGraded mapInvolutioncomplement
  • Mp00117LabeledGraph → LabeledGraphIdempotentGraded mapOre closure
  • Mp00147LabeledGraph → LabeledGraphGraded mapsquare
  • Mp00152LabeledGraph → IntegerCompositionSurjectionGraded mapLaplacian multiplicities
  • Mp00154LabeledGraph → LabeledGraphIdempotentcore
  • Mp00156LabeledGraph → LabeledGraphline graph
  • Mp00157LabeledGraph → LabeledGraphGraded mapInvolutionconnected complement
  • Mp00160Permutation → LabeledGraphGraded mapgraph of inversions
  • Mp00184IntegerComposition → LabeledGraphInjectionGraded mapto threshold graph
  • Mp00198Posets → LabeledGraphGraded mapincomparability graph
  • Mp00203LabeledGraph → LabeledGraphInjectionGraded mapcone
  • Mp00243LabeledGraph → Posetsweak duplicate order
  • Mp00247LabeledGraph → LabeledGraphIdempotentde-duplicate
  • Mp00250LabeledGraph → LabeledGraphclique graph
  • Mp00251LabeledGraph → IntegerPartitionclique sizes
  • Mp00259LabeledGraph → LabeledGraphInjectionGraded mapvertex addition
  • Mp00264LabeledGraph → LabeledGraphIdempotentdelete endpoints
  • Mp00266LabeledGraph → Latticesconnected vertex partitions
  • Mp00274LabeledGraph → LabeledGraphblock-cut tree
  • Mp00275LabeledGraph → IntegerPartitionSurjectionto edge-partition of connected components
  • Mp00276LabeledGraph → IntegerPartitionto edge-partition of biconnected components
  • Mp00318LabeledGraph → LabeledGraphInvolutiondual on components
  • Mp00324LabeledGraph → IntegerCompositionGraded mapchromatic difference sequence
  • Mp00335Lattices → LabeledGraphzero-divisor graph

Enumeration

About