Barbell Graph

Author

Eric W. Weisstein
August 30, 2024

This notebook downloaded from http://mathworld.wolfram.com/notebooks/GraphTheory/BarbellGraph.nb.

For more information, see Eric's MathWorld entry http://mathworld.wolfram.com/BarbellGraph.html.

©2024 Wolfram Research, Inc. except for portions noted otherwise

Figures

Graphs.m

GraphicsGrid[Partition[Table[Show[BarbellGraph[n,VertexSize->{"Scaled",.05},System`VertexStyle->Red,System`EdgeStyle->Black],PlotLabel->Style[HoldForm[n]==n,FontFamily->"Times"]],{n,3,8}],UpTo[3]],Dividers->All,ImageSize->500,Spacings->{-50,20}]

Special Cases

Sort[{GraphData[#,"NotationRules","Barbell"],GraphData[#,"Name"]}&/@DeleteCases[GraphData["Barbell"],{"Barbell",_}]]

Embeddings

<<MathWorld`Graphs`

{"Barbell", 3}

Names

GraphData[{"Barbell",3},"StandardName"]

GraphData[{"Barbell",3},"StandardNames"]

Primary

GraphData[{"Barbell",3}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",3},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",3},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",3},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Barbell",3},"Edges"]

g=BarbellGraph[3]

RotateGraph[Graph[GraphData[{"Barbell",3},"Edges"],GraphLayout->"CircularEmbedding"],Pi/2]

v=CirclePoints[6];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[6,4,5,6,1,2,3,1]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

GraphPlot@

Rotate[,Pi]

s=Sqrt[3]/2;
v={{0,0},{1/2,s},{1,0},{2,0},{3,0},{5/2,s}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[3,2,1,3,4,5,6,4]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

s=1;
v={{0,0},{1,s},{1,0},{2,0},{3,0},{2,s}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[3,2,1,3,4,5,6,4]},VertexCoordinates->v,VertexLabels->Automatic]

s=1;
v={{0,0},{0,s},{1,0},{2,0},{3,0},{3,s}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[3,2,1,3,4,5,6,4]},VertexCoordinates->v,VertexLabels->Automatic]

gs={,};

v=CirclePoints[6];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[5,2,6,4,2],e[1,3,5,1]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

v=Join[CirclePoints[3],CirclePoints[1/2,3]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[5,4,6,5,2,3,1,2]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

BarbellGraph[3,GraphLayout->"NestedEmbedding"]

RotateGraph[,Pi]

s=Sqrt[3]/2;
v={{0,0},{1,0},{1,1},{0,1},{1-s,1/2},{s,1/2}};
g=Graph[Range@Length@v,UndirectedEdge@@@{e[1,6,4,1,2,3,5,2]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

s=Sqrt[3]/2;
v={{-1/2,0},{1/2,0},{0,s},{0,s+1},{-1/2,1},{1/2,1}};
g=Graph[Range@Length@v,UndirectedEdge@@@{e[3,2,1,3,4,6,5,4]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

s=Sqrt[3]/2;
v={{0,0},{0,1},{1,0},{1,1},{-s,1/2},{1+s,1/2}};
g=CenterGraph@Graph[Range@Length@v,UndirectedEdge@@@{e[1,2,5,1,3,6,4,3]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

gs=UnlabelGraph/@{,,}

Degenerate

GraphData[{"Barbell",3},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",3},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",3},"Configuration"]

GraphData[{"Barbell",3},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",3},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",3},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",3},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",3},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",3},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",3},"Graph","All"],g],{_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",3},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Barbell",3},"Planar"]

GraphData[{"Barbell",3},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Barbell",3}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Barbell",3}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Barbell",3}]])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"Barbell",3},{"RCN","CN"}]

GraphData[{"Barbell",3},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",3}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",3}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",3}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",3}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",3}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",3}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",3}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Barbell",3},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",3}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Barbell",3},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",3}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",3},"LocalCrossingNumber"]

GraphData[{"Barbell",3},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",3}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",3}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",3}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",3},"Circulant"]

GraphData[{"Barbell",3},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",3},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Barbell",3},"Line"]

LineGraphQ[GraphData[{"Barbell",3}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",3}&]

RootGraph[GraphData[{"Barbell",3}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"Barbell",3},"Halin"]

GraphData[{"Barbell",3},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",3},"Rigid"]

GraphData[{"Barbell",3},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",3},"Flexible"]

GraphData[{"Barbell",3},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",3},"LCF"]

GraphData[{"Barbell",3},"HamiltonianCycleCount"]

GraphData[{"Barbell",3},"LCFSignature"]

GraphData[{"Barbell",3},"LCFNotations"]

GraphData[{"Barbell",3},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",3},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",3}],Debug->True]//Timing

GraphData[{"Barbell",3},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",3},"VertexList"],GraphData[{"Barbell",3},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",3},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",3}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Barbell",3}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Barbell",3},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Barbell",3}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Matchstick

GraphData[{"Barbell",3},"Matchstick"]

GraphData[{"Barbell",3},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",3},"Edges"]]

3D All

GraphData[{"Barbell",3},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",3},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",3},"Polyhedral"]

GraphData[{"Barbell",3},"Graph",{"3D","Polyhedron"}]

{"Barbell", 4}

Names

GraphData[{"Barbell",4},"StandardName"]

GraphData[{"Barbell",4},"StandardNames"]

Primary

GraphData[{"Barbell",4}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",4},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",4},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",4},"EdgeList"]]

Default embedding

BarbellGraph[4]

RotateGraph[Graph[GraphData[{"Barbell",4},"Edges"],GraphLayout->"CircularEmbedding"],3Pi/8]

v=CirclePoints[8];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[6,8,5,6,7,8,1,2,3,4,1,3],{2,4},{5,7}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

v=Join[CirclePoints[{-3/2,0},{1,0},3],CirclePoints[{3/2,0},{1,-Pi},3],{{-3/2,0},{3/2,0}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[2,7,1,2,3,1,4,6,5,4,8,6],{3,7},{5,8}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

GraphPlot@

GraphPlot@RotateGraph[GraphicsToGraph@,π-Pi/2]

v=Join[CirclePoints[3],CirclePoints[1/2,3],{{0,0}}];
AppendTo[v,3/4v[[1]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[1,2,3,1,8,2,5,6,4,5,7,6],{4,7},{8,3}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

v=Join[CirclePoints[{1,Pi/2},6],#{-1/4,0}&/@{-1,1}];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[4,6,8,2,4],e[1,3,7,5,1,7],{2,6},{3,5},{4,8},{1,4}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

GraphPlot@

Degenerate

GraphData[{"Barbell",4},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",4},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",4},"Configuration"]

GraphData[{"Barbell",4},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",4},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",4},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",4},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",4},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",4},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",4},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",4},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Barbell",4},"Planar"]

GraphData[{"Barbell",4},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Barbell",4}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Barbell",4}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Barbell",4}]])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"Barbell",4},{"RCN","CN"}]

GraphData[{"Barbell",4},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",4}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",4}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",4}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",4}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",4}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",4}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",4}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Barbell",4},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",4}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Barbell",4},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",4}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",4},"LocalCrossingNumber"]

GraphData[{"Barbell",4},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",4}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",4}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",4}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",4},"Circulant"]

GraphData[{"Barbell",4},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",4},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

GraphPlot@

Select[gs,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Barbell",4},"Line"]

LineGraphQ[GraphData[{"Barbell",4}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",4}&]

RootGraph[GraphData[{"Barbell",4}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"Barbell",4},"Halin"]

GraphData[{"Barbell",4},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",4},"Rigid"]

GraphData[{"Barbell",4},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",4},"Flexible"]

GraphData[{"Barbell",4},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",4},"LCF"]

GraphData[{"Barbell",4},"HamiltonianCycleCount"]

GraphData[{"Barbell",4},"LCFSignature"]

GraphData[{"Barbell",4},"LCFNotations"]

GraphData[{"Barbell",4},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",4},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",4}],Debug->True]//Timing

GraphData[{"Barbell",4},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",4},"VertexList"],GraphData[{"Barbell",4},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",4},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",4}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Barbell",4}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"Barbell",4},"Matchstick"]

GraphData[{"Barbell",4},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",4},"Edges"]]

3D All

GraphData[{"Barbell",4},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",4},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",4},"Polyhedral"]

GraphData[{"Barbell",4},"Graph",{"3D","Polyhedron"}]

{"Barbell", 5}

Names

GraphData[{"Barbell",5},"StandardName"]

GraphData[{"Barbell",5},"StandardNames"]

Primary

GraphData[{"Barbell",5}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",5},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",5},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",5},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Barbell",5},"Edges"]

g=BarbellGraph[5]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",5},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",5},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",5},"Configuration"]

GraphData[{"Barbell",5},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",5},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",5},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",5},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",5},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",5},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",5},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",5},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",5},"Hamiltonian"]

GraphData[{"Barbell",5},"HamiltonianCycleCount"]

g=BarbellGraph[5,GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",5},"Planar"]

GraphData[{"Barbell",5},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",5},{"RCN","CN"}]

GraphData[{"Barbell",5},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",5}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",5}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",5}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",5}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",5}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",5}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",5}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",5}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",5},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",5}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",5},"LocalCrossingNumber"]

GraphData[{"Barbell",5},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",5}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",5}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",5}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",5},"Circulant"]

GraphData[{"Barbell",5},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",5},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",5},"Line"]

LineGraphQ[GraphData[{"Barbell",5}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",5}&]

RootGraph[GraphData[{"Barbell",5}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"Barbell",5},"Halin"]

GraphData[{"Barbell",5},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",5},"Rigid"]

GraphData[{"Barbell",5},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",5},"Flexible"]

GraphData[{"Barbell",5},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",5},"LCF"]

GraphData[{"Barbell",5},"HamiltonianCycleCount"]

GraphData[{"Barbell",5},"LCFSignature"]

GraphData[{"Barbell",5},"LCFNotations"]

GraphData[{"Barbell",5},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",5},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",5}],Debug->True]//Timing

GraphData[{"Barbell",5},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",5},"VertexList"],GraphData[{"Barbell",5},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",5},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",5}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",5},"Matchstick"]

GraphData[{"Barbell",5},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",5},"Edges"]]

3D All

GraphData[{"Barbell",5},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",5},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",5},"Polyhedral"]

GraphData[{"Barbell",5},"Graph",{"3D","Polyhedron"}]

{"Barbell", 6}

Names

GraphData[{"Barbell",6},"StandardName"]

GraphData[{"Barbell",6},"StandardNames"]

Primary

GraphData[{"Barbell",6}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",6},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",6},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",6},"EdgeList"]]

Default embedding

BarbellGraph[6]

GraphPlot@GraphData[{"Barbell",6},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",6},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",6},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",6},"Configuration"]

GraphData[{"Barbell",6},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",6},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",6},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",6},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",6},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",6},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",6},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",6},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",6},"Hamiltonian"]

GraphData[{"Barbell",6},"HamiltonianCycleCount"]

g=BarbellGraph[6,GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",6},"Planar"]

GraphData[{"Barbell",6},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",6},{"RCN","CN"}]

GraphData[{"Barbell",6},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",6}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",6}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",6}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",6}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",6}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",6}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",6}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",6}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",6},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",6}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",6},"LocalCrossingNumber"]

GraphData[{"Barbell",6},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",6}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",6}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",6}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",6},"Circulant"]

GraphData[{"Barbell",6},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",6},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",6},"Line"]

LineGraphQ[GraphData[{"Barbell",6}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",6}&]

RootGraph[GraphData[{"Barbell",6}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",6},"Halin"]

GraphData[{"Barbell",6},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",6},"Rigid"]

GraphData[{"Barbell",6},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",6},"Flexible"]

GraphData[{"Barbell",6},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",6},"LCF"]

GraphData[{"Barbell",6},"HamiltonianCycleCount"]

GraphData[{"Barbell",6},"LCFSignature"]

GraphData[{"Barbell",6},"LCFNotations"]

GraphData[{"Barbell",6},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",6},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",6}],Debug->True]//Timing

GraphData[{"Barbell",6},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",6},"VertexList"],GraphData[{"Barbell",6},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",6},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",6}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",6},"Matchstick"]

GraphData[{"Barbell",6},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",6},"Edges"]]

3D All

GraphData[{"Barbell",6},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",6},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",6},"Polyhedral"]

GraphData[{"Barbell",6},"Graph",{"3D","Polyhedron"}]

{"Barbell", 7}

Names

GraphData[{"Barbell",7},"StandardName"]

GraphData[{"Barbell",7},"StandardNames"]

Primary

GraphData[{"Barbell",7}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",7},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",7},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",7},"EdgeList"]]

Default embedding

BarbellGraph[7]

GraphPlot@GraphData[{"Barbell",7},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",7},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",7},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",7},"Configuration"]

GraphData[{"Barbell",7},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",7},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",7},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",7},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",7},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",7},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",7},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",7},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",7},"Hamiltonian"]

GraphData[{"Barbell",7},"HamiltonianCycleCount"]

g=BarbellGraph[7,GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",7},"Planar"]

GraphData[{"Barbell",7},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",7},{"RCN","CN"}]

GraphData[{"Barbell",7},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",7}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",7}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",7}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",7}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",7}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",7}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",7}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",7}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",7},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",7}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Show[,Axes->True]

v={#,If[#>1,1-#2,#2]}&@@@GraphEmbedding[g0=];
g=Graph[Range[Length[v]],EdgeList[g0],VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

BilateralGraphEmbeddingQ[g]

MinimalLocalCrossing

GraphData[{"Barbell",7},"LocalCrossingNumber"]

GraphData[{"Barbell",7},"Graph","MinimalLocalCrossing"]//StyleGraphs

RectilinearLocalCrossingCount@

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",7}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",7}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",7}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",7},"Circulant"]

GraphData[{"Barbell",7},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",7},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",7},"Line"]

LineGraphQ[GraphData[{"Barbell",7}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",7}&]

RootGraph[GraphData[{"Barbell",7}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",7},"Halin"]

GraphData[{"Barbell",7},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",7},"Rigid"]

GraphData[{"Barbell",7},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",7},"Flexible"]

GraphData[{"Barbell",7},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",7},"LCF"]

GraphData[{"Barbell",7},"HamiltonianCycleCount"]

GraphData[{"Barbell",7},"LCFSignature"]

GraphData[{"Barbell",7},"LCFNotations"]

GraphData[{"Barbell",7},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",7},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",7}],Debug->True]//Timing

GraphData[{"Barbell",7},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",7},"VertexList"],GraphData[{"Barbell",7},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",7},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",7}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",7},"Matchstick"]

GraphData[{"Barbell",7},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",7},"Edges"]]

3D All

GraphData[{"Barbell",7},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",7},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",7},"Polyhedral"]

GraphData[{"Barbell",7},"Graph",{"3D","Polyhedron"}]

{"Barbell", 8}

Names

GraphData[{"Barbell",8},"StandardName"]

GraphData[{"Barbell",8},"StandardNames"]

Primary

GraphData[{"Barbell",8}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",8},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",8},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",8},"EdgeList"]]

Default embedding

BarbellGraph[8]

GraphPlot@GraphData[{"Barbell",8},"Edges"]

Degenerate

GraphData[{"Barbell",8},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",8},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",8},"Configuration"]

GraphData[{"Barbell",8},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",8},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",8},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",8},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",8},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",8},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",8},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",8},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",8},"Hamiltonian"]

GraphData[{"Barbell",8},"HamiltonianCycleCount"]

g=BarbellGraph[8,GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",8},"Planar"]

GraphData[{"Barbell",8},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",8},{"RCN","CN"}]

GraphData[{"Barbell",8},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",8}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",8}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",8}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",8}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",8}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",8}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",8}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",8}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",8},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",8}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

g0=GraphData[{"Complete",8},"Graph","MinimalRectilinearCrossing"][[1]]

GraphEmbedding[%]

g=EdgeAdd[MyGraphUnion[RotateGraph[g0,-Pi/2],RotateGraph[g0,Pi/2],VertexLabels->Automatic],UndirectedEdge[5,13]]

RecognizeGraph[g]

MinimalLocalCrossing

GraphData[{"Barbell",8},"LocalCrossingNumber"]

GraphData[{"Barbell",8},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",8}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",8}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",8}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",8},"Circulant"]

GraphData[{"Barbell",8},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",8},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",8},"Line"]

LineGraphQ[GraphData[{"Barbell",8}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",8}&]

RootGraph[GraphData[{"Barbell",8}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",8},"Halin"]

GraphData[{"Barbell",8},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",8},"Rigid"]

GraphData[{"Barbell",8},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",8},"Flexible"]

GraphData[{"Barbell",8},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",8},"LCF"]

GraphData[{"Barbell",8},"HamiltonianCycleCount"]

GraphData[{"Barbell",8},"LCFSignature"]

GraphData[{"Barbell",8},"LCFNotations"]

GraphData[{"Barbell",8},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",8},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",8}],Debug->True]//Timing

GraphData[{"Barbell",8},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",8},"VertexList"],GraphData[{"Barbell",8},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",8},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",8}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",8},"Matchstick"]

GraphData[{"Barbell",8},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",8},"Edges"]]

3D All

GraphData[{"Barbell",8},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",8},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",8},"Polyhedral"]

GraphData[{"Barbell",8},"Graph",{"3D","Polyhedron"}]

{"Barbell", 9}

Names

GraphData[{"Barbell",9},"StandardName"]

GraphData[{"Barbell",9},"StandardNames"]

Primary

GraphData[{"Barbell",9}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",9},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",9},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",9},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",9}[[2]]]

GraphPlot@GraphData[{"Barbell",9},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",9},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",9},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",9},"Configuration"]

GraphData[{"Barbell",9},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",9},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",9},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",9},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",9},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",9},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",9},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",9},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",9},"Hamiltonian"]

GraphData[{"Barbell",9},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",9}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",9},"Planar"]

GraphData[{"Barbell",9},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",9},{"RCN","CN"}]

GraphData[{"Barbell",9},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",9}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",9}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",9}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",9}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",9}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",9}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",9}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",9}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",9},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",9}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

Quit

g0=GraphData[{"Complete",9},"Graph","MinimalRectilinearCrossing"][[1]]

GraphEmbedding[%]

g1=EdgeAdd[MyGraphUnion[RotateGraph[g0,-Pi/2],RotateGraph[g0,Pi/2],VertexLabels->Automatic],6\[UndirectedEdge]15]

g2=EdgeAdd[MyGraphUnion[RotateGraph[g0,-Pi/2],With[{g1=RotateGraph[g0,Pi/2]},Annotate[g1,VertexCoordinates->({#,-#2}&@@@GraphEmbedding[g1])]],VertexLabels->Automatic],6\[UndirectedEdge]15]

RecognizeGraph/@{g1,g2}

gs={g1,g2}

MinimalLocalCrossing

GraphData[{"Barbell",9},"LocalCrossingNumber"]

GraphData[{"Barbell",9},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",9}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",9}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",9}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",9},"Circulant"]

GraphData[{"Barbell",9},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",9},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",9},"Line"]

LineGraphQ[GraphData[{"Barbell",9}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",9}&]

RootGraph[GraphData[{"Barbell",9}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",9},"Halin"]

GraphData[{"Barbell",9},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",9},"Rigid"]

GraphData[{"Barbell",9},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",9},"Flexible"]

GraphData[{"Barbell",9},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",9},"LCF"]

GraphData[{"Barbell",9},"HamiltonianCycleCount"]

GraphData[{"Barbell",9},"LCFSignature"]

GraphData[{"Barbell",9},"LCFNotations"]

GraphData[{"Barbell",9},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",9},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",9}],Debug->True]//Timing

GraphData[{"Barbell",9},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",9},"VertexList"],GraphData[{"Barbell",9},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",9},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",9}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",9},"Matchstick"]

GraphData[{"Barbell",9},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",9},"Edges"]]

3D All

GraphData[{"Barbell",9},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",9},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",9},"Polyhedral"]

GraphData[{"Barbell",9},"Graph",{"3D","Polyhedron"}]

{"Barbell", 10}

Names

GraphData[{"Barbell",10},"StandardName"]

GraphData[{"Barbell",10},"StandardNames"]

Primary

GraphData[{"Barbell",10}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",10},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",10},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",10},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",10}[[2]]]

GraphPlot@GraphData[{"Barbell",10},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",10},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",10},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",10},"Configuration"]

GraphData[{"Barbell",10},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",10},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",10},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",10},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",10},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",10},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",10},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",10},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",10},"Hamiltonian"]

GraphData[{"Barbell",10},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",10}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",10},"Planar"]

GraphData[{"Barbell",10},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",10},{"RCN","CN"}]

GraphData[{"Barbell",10},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",10}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",10}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",10}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",10}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",10}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",10}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",10}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",10}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",10},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",10}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",10},"LocalCrossingNumber"]

GraphData[{"Barbell",10},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",10}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",10}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",10}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",10},"Circulant"]

GraphData[{"Barbell",10},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",10},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",10},"Line"]

LineGraphQ[GraphData[{"Barbell",10}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",10}&]

RootGraph[GraphData[{"Barbell",10}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",10},"Halin"]

GraphData[{"Barbell",10},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",10},"Rigid"]

GraphData[{"Barbell",10},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",10},"Flexible"]

GraphData[{"Barbell",10},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",10},"LCF"]

GraphData[{"Barbell",10},"HamiltonianCycleCount"]

GraphData[{"Barbell",10},"LCFSignature"]

GraphData[{"Barbell",10},"LCFNotations"]

GraphData[{"Barbell",10},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",10},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",10}],Debug->True]//Timing

GraphData[{"Barbell",10},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",10},"VertexList"],GraphData[{"Barbell",10},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",10},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",10}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",10},"Matchstick"]

GraphData[{"Barbell",10},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",10},"Edges"]]

3D All

GraphData[{"Barbell",10},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",10},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",10},"Polyhedral"]

GraphData[{"Barbell",10},"Graph",{"3D","Polyhedron"}]

{"Barbell", 11}

Names

GraphData[{"Barbell",11},"StandardName"]

GraphData[{"Barbell",11},"StandardNames"]

Primary

GraphData[{"Barbell",11}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",11},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",11},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",11},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",11}[[2]]]

GraphPlot@GraphData[{"Barbell",11},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",11},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",11},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",11},"Configuration"]

GraphData[{"Barbell",11},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",11},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",11},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",11},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",11},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",11},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",11},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",11},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",11},"Hamiltonian"]

GraphData[{"Barbell",11},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",11}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",11},"Planar"]

GraphData[{"Barbell",11},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",11},{"RCN","CN"}]

GraphData[{"Barbell",11},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",11}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",11}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",11}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",11}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",11}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",11}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",11}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",11}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",11},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",11}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",11},"LocalCrossingNumber"]

GraphData[{"Barbell",11},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",11}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",11}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",11}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",11},"Circulant"]

GraphData[{"Barbell",11},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",11},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",11},"Line"]

LineGraphQ[GraphData[{"Barbell",11}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",11}&]

RootGraph[GraphData[{"Barbell",11}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",11},"Halin"]

GraphData[{"Barbell",11},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",11},"Rigid"]

GraphData[{"Barbell",11},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",11},"Flexible"]

GraphData[{"Barbell",11},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",11},"LCF"]

GraphData[{"Barbell",11},"HamiltonianCycleCount"]

GraphData[{"Barbell",11},"LCFSignature"]

GraphData[{"Barbell",11},"LCFNotations"]

GraphData[{"Barbell",11},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",11},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",11}],Debug->True]//Timing

GraphData[{"Barbell",11},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",11},"VertexList"],GraphData[{"Barbell",11},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",11},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",11}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",11},"Matchstick"]

GraphData[{"Barbell",11},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",11},"Edges"]]

3D All

GraphData[{"Barbell",11},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",11},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",11},"Polyhedral"]

GraphData[{"Barbell",11},"Graph",{"3D","Polyhedron"}]

{"Barbell", 12}

Names

GraphData[{"Barbell",12},"StandardName"]

GraphData[{"Barbell",12},"StandardNames"]

Primary

GraphData[{"Barbell",12}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",12},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",12},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",12},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",12}[[2]]]

GraphPlot@GraphData[{"Barbell",12},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",12},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",12},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",12},"Configuration"]

GraphData[{"Barbell",12},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",12},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",12},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",12},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",12},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",12},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",12},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",12},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",12},"Hamiltonian"]

GraphData[{"Barbell",12},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",12}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",12},"Planar"]

GraphData[{"Barbell",12},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",12},{"RCN","CN"}]

GraphData[{"Barbell",12},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",12}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",12}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",12}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",12}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",12}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",12}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",12}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",12}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",12},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",12}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",12},"LocalCrossingNumber"]

GraphData[{"Barbell",12},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",12}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",12}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",12}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",12},"Circulant"]

GraphData[{"Barbell",12},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",12},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",12},"Line"]

LineGraphQ[GraphData[{"Barbell",12}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",12}&]

RootGraph[GraphData[{"Barbell",12}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",12},"Halin"]

GraphData[{"Barbell",12},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",12},"Rigid"]

GraphData[{"Barbell",12},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",12},"Flexible"]

GraphData[{"Barbell",12},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",12},"LCF"]

GraphData[{"Barbell",12},"HamiltonianCycleCount"]

GraphData[{"Barbell",12},"LCFSignature"]

GraphData[{"Barbell",12},"LCFNotations"]

GraphData[{"Barbell",12},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",12},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",12}],Debug->True]//Timing

GraphData[{"Barbell",12},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",12},"VertexList"],GraphData[{"Barbell",12},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",12},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",12}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",12},"Matchstick"]

GraphData[{"Barbell",12},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",12},"Edges"]]

3D All

GraphData[{"Barbell",12},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",12},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",12},"Polyhedral"]

GraphData[{"Barbell",12},"Graph",{"3D","Polyhedron"}]

{"Barbell", 13}

Names

GraphData[{"Barbell",13},"StandardName"]

GraphData[{"Barbell",13},"StandardNames"]

Primary

GraphData[{"Barbell",13}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",13},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",13},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",13},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",13}[[2]]]

GraphPlot@GraphData[{"Barbell",13},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",13},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",13},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",13},"Configuration"]

GraphData[{"Barbell",13},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",13},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",13},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",13},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",13},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",13},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",13},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",13},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",13},"Hamiltonian"]

GraphData[{"Barbell",13},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",13}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",13},"Planar"]

GraphData[{"Barbell",13},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",13},{"RCN","CN"}]

GraphData[{"Barbell",13},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",13}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",13}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",13}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",13}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",13}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",13}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",13}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",13}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",13},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",13}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",13},"LocalCrossingNumber"]

GraphData[{"Barbell",13},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",13}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",13}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",13}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",13},"Circulant"]

GraphData[{"Barbell",13},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",13},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",13},"Line"]

LineGraphQ[GraphData[{"Barbell",13}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",13}&]

RootGraph[GraphData[{"Barbell",13}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",13},"Halin"]

GraphData[{"Barbell",13},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",13},"Rigid"]

GraphData[{"Barbell",13},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",13},"Flexible"]

GraphData[{"Barbell",13},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",13},"LCF"]

GraphData[{"Barbell",13},"HamiltonianCycleCount"]

GraphData[{"Barbell",13},"LCFSignature"]

GraphData[{"Barbell",13},"LCFNotations"]

GraphData[{"Barbell",13},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",13},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",13}],Debug->True]//Timing

GraphData[{"Barbell",13},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",13},"VertexList"],GraphData[{"Barbell",13},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",13},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",13}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",13},"Matchstick"]

GraphData[{"Barbell",13},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",13},"Edges"]]

3D All

GraphData[{"Barbell",13},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",13},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",13},"Polyhedral"]

GraphData[{"Barbell",13},"Graph",{"3D","Polyhedron"}]

{"Barbell", 14}

Names

GraphData[{"Barbell",14},"StandardName"]

GraphData[{"Barbell",14},"StandardNames"]

Primary

GraphData[{"Barbell",14}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",14},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",14},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",14},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",14}[[2]]]

GraphPlot@GraphData[{"Barbell",14},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",14},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",14},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",14},"Configuration"]

GraphData[{"Barbell",14},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",14},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",14},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",14},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",14},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",14},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",14},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",14},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",14},"Hamiltonian"]

GraphData[{"Barbell",14},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",14}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",14},"Planar"]

GraphData[{"Barbell",14},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",14},{"RCN","CN"}]

GraphData[{"Barbell",14},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",14}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",14}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",14}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",14}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",14}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",14}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",14}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",14}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",14},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",14}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",14},"LocalCrossingNumber"]

GraphData[{"Barbell",14},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",14}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",14}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",14}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",14},"Circulant"]

GraphData[{"Barbell",14},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",14},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",14},"Line"]

LineGraphQ[GraphData[{"Barbell",14}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",14}&]

RootGraph[GraphData[{"Barbell",14}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",14},"Halin"]

GraphData[{"Barbell",14},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",14},"Rigid"]

GraphData[{"Barbell",14},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",14},"Flexible"]

GraphData[{"Barbell",14},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",14},"LCF"]

GraphData[{"Barbell",14},"HamiltonianCycleCount"]

GraphData[{"Barbell",14},"LCFSignature"]

GraphData[{"Barbell",14},"LCFNotations"]

GraphData[{"Barbell",14},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",14},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",14}],Debug->True]//Timing

GraphData[{"Barbell",14},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",14},"VertexList"],GraphData[{"Barbell",14},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",14},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",14}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",14},"Matchstick"]

GraphData[{"Barbell",14},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",14},"Edges"]]

3D All

GraphData[{"Barbell",14},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",14},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",14},"Polyhedral"]

GraphData[{"Barbell",14},"Graph",{"3D","Polyhedron"}]

{"Barbell", 15}

Names

GraphData[{"Barbell",15},"StandardName"]

GraphData[{"Barbell",15},"StandardNames"]

Primary

GraphData[{"Barbell",15}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",15},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",15},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",15},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",15}[[2]]]

GraphPlot@GraphData[{"Barbell",15},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",15},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",15},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",15},"Configuration"]

GraphData[{"Barbell",15},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",15},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",15},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",15},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",15},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",15},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",15},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",15},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",15},"Hamiltonian"]

GraphData[{"Barbell",15},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",15}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",15},"Planar"]

GraphData[{"Barbell",15},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",15},{"RCN","CN"}]

GraphData[{"Barbell",15},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",15}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",15}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",15}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",15}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",15}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",15}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",15}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",15}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",15},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",15}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",15},"LocalCrossingNumber"]

GraphData[{"Barbell",15},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",15}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",15}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",15}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",15},"Circulant"]

GraphData[{"Barbell",15},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",15},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",15},"Line"]

LineGraphQ[GraphData[{"Barbell",15}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",15}&]

RootGraph[GraphData[{"Barbell",15}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",15},"Halin"]

GraphData[{"Barbell",15},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",15},"Rigid"]

GraphData[{"Barbell",15},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",15},"Flexible"]

GraphData[{"Barbell",15},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",15},"LCF"]

GraphData[{"Barbell",15},"HamiltonianCycleCount"]

GraphData[{"Barbell",15},"LCFSignature"]

GraphData[{"Barbell",15},"LCFNotations"]

GraphData[{"Barbell",15},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",15},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",15}],Debug->True]//Timing

GraphData[{"Barbell",15},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",15},"VertexList"],GraphData[{"Barbell",15},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",15},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",15}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",15},"Matchstick"]

GraphData[{"Barbell",15},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",15},"Edges"]]

3D All

GraphData[{"Barbell",15},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",15},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",15},"Polyhedral"]

GraphData[{"Barbell",15},"Graph",{"3D","Polyhedron"}]

{"Barbell", 16}

Names

GraphData[{"Barbell",16},"StandardName"]

GraphData[{"Barbell",16},"StandardNames"]

Primary

GraphData[{"Barbell",16}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",16},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",16},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",16},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",16}[[2]]]

GraphPlot@GraphData[{"Barbell",16},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",16},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",16},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",16},"Configuration"]

GraphData[{"Barbell",16},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",16},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",16},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",16},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",16},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",16},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",16},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",16},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",16},"Hamiltonian"]

GraphData[{"Barbell",16},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",16}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",16},"Planar"]

GraphData[{"Barbell",16},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",16},{"RCN","CN"}]

GraphData[{"Barbell",16},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",16}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",16}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",16}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",16}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",16}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",16}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",16}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",16}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",16},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",16}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",16},"LocalCrossingNumber"]

GraphData[{"Barbell",16},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",16}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",16}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",16}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",16},"Circulant"]

GraphData[{"Barbell",16},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",16},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",16},"Line"]

LineGraphQ[GraphData[{"Barbell",16}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",16}&]

RootGraph[GraphData[{"Barbell",16}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",16},"Halin"]

GraphData[{"Barbell",16},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",16},"Rigid"]

GraphData[{"Barbell",16},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",16},"Flexible"]

GraphData[{"Barbell",16},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",16},"LCF"]

GraphData[{"Barbell",16},"HamiltonianCycleCount"]

GraphData[{"Barbell",16},"LCFSignature"]

GraphData[{"Barbell",16},"LCFNotations"]

GraphData[{"Barbell",16},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",16},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",16}],Debug->True]//Timing

GraphData[{"Barbell",16},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",16},"VertexList"],GraphData[{"Barbell",16},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",16},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",16}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",16},"Matchstick"]

GraphData[{"Barbell",16},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",16},"Edges"]]

3D All

GraphData[{"Barbell",16},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",16},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",16},"Polyhedral"]

GraphData[{"Barbell",16},"Graph",{"3D","Polyhedron"}]

{"Barbell", 17}

Names

GraphData[{"Barbell",17},"StandardName"]

GraphData[{"Barbell",17},"StandardNames"]

Primary

GraphData[{"Barbell",17}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",17},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",17},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",17},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",17}[[2]]]

GraphPlot@GraphData[{"Barbell",17},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",17},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",17},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",17},"Configuration"]

GraphData[{"Barbell",17},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",17},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",17},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",17},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",17},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",17},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",17},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",17},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",17},"Hamiltonian"]

GraphData[{"Barbell",17},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",17}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",17},"Planar"]

GraphData[{"Barbell",17},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",17},{"RCN","CN"}]

GraphData[{"Barbell",17},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",17}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",17}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",17}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",17}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",17}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",17}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",17}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",17}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",17},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",17}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",17},"LocalCrossingNumber"]

GraphData[{"Barbell",17},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",17}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",17}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",17}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",17},"Circulant"]

GraphData[{"Barbell",17},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",17},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",17},"Line"]

LineGraphQ[GraphData[{"Barbell",17}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",17}&]

RootGraph[GraphData[{"Barbell",17}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",17},"Halin"]

GraphData[{"Barbell",17},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",17},"Rigid"]

GraphData[{"Barbell",17},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",17},"Flexible"]

GraphData[{"Barbell",17},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",17},"LCF"]

GraphData[{"Barbell",17},"HamiltonianCycleCount"]

GraphData[{"Barbell",17},"LCFSignature"]

GraphData[{"Barbell",17},"LCFNotations"]

GraphData[{"Barbell",17},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",17},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",17}],Debug->True]//Timing

GraphData[{"Barbell",17},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",17},"VertexList"],GraphData[{"Barbell",17},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",17},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",17}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",17},"Matchstick"]

GraphData[{"Barbell",17},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",17},"Edges"]]

3D All

GraphData[{"Barbell",17},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",17},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",17},"Polyhedral"]

GraphData[{"Barbell",17},"Graph",{"3D","Polyhedron"}]

{"Barbell", 18}

Names

GraphData[{"Barbell",18},"StandardName"]

GraphData[{"Barbell",18},"StandardNames"]

Primary

GraphData[{"Barbell",18}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",18},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",18},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",18},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",18}[[2]]]

GraphPlot@GraphData[{"Barbell",18},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",18},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",18},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",18},"Configuration"]

GraphData[{"Barbell",18},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",18},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",18},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",18},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",18},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",18},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",18},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",18},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",18},"Hamiltonian"]

GraphData[{"Barbell",18},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",18}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",18},"Planar"]

GraphData[{"Barbell",18},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",18},{"RCN","CN"}]

GraphData[{"Barbell",18},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",18}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",18}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",18}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",18}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",18}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",18}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",18}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",18}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",18},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",18}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",18},"LocalCrossingNumber"]

GraphData[{"Barbell",18},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",18}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",18}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",18}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",18},"Circulant"]

GraphData[{"Barbell",18},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",18},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",18},"Line"]

LineGraphQ[GraphData[{"Barbell",18}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",18}&]

RootGraph[GraphData[{"Barbell",18}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",18},"Halin"]

GraphData[{"Barbell",18},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",18},"Rigid"]

GraphData[{"Barbell",18},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",18},"Flexible"]

GraphData[{"Barbell",18},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",18},"LCF"]

GraphData[{"Barbell",18},"HamiltonianCycleCount"]

GraphData[{"Barbell",18},"LCFSignature"]

GraphData[{"Barbell",18},"LCFNotations"]

GraphData[{"Barbell",18},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",18},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",18}],Debug->True]//Timing

GraphData[{"Barbell",18},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",18},"VertexList"],GraphData[{"Barbell",18},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",18},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",18}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",18},"Matchstick"]

GraphData[{"Barbell",18},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",18},"Edges"]]

3D All

GraphData[{"Barbell",18},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",18},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",18},"Polyhedral"]

GraphData[{"Barbell",18},"Graph",{"3D","Polyhedron"}]

{"Barbell", 19}

Names

GraphData[{"Barbell",19},"StandardName"]

GraphData[{"Barbell",19},"StandardNames"]

Primary

GraphData[{"Barbell",19}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",19},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",19},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",19},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",19}[[2]]]

GraphPlot@GraphData[{"Barbell",19},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",19},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",19},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",19},"Configuration"]

GraphData[{"Barbell",19},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",19},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",19},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",19},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",19},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",19},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",19},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",19},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",19},"Hamiltonian"]

GraphData[{"Barbell",19},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",19}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",19},"Planar"]

GraphData[{"Barbell",19},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",19},{"RCN","CN"}]

GraphData[{"Barbell",19},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",19}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",19}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",19}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",19}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",19}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",19}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",19}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",19}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",19},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",19}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",19},"LocalCrossingNumber"]

GraphData[{"Barbell",19},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",19}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",19}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",19}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",19},"Circulant"]

GraphData[{"Barbell",19},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",19},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",19},"Line"]

LineGraphQ[GraphData[{"Barbell",19}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",19}&]

RootGraph[GraphData[{"Barbell",19}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",19},"Halin"]

GraphData[{"Barbell",19},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",19},"Rigid"]

GraphData[{"Barbell",19},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",19},"Flexible"]

GraphData[{"Barbell",19},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",19},"LCF"]

GraphData[{"Barbell",19},"HamiltonianCycleCount"]

GraphData[{"Barbell",19},"LCFSignature"]

GraphData[{"Barbell",19},"LCFNotations"]

GraphData[{"Barbell",19},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",19},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",19}],Debug->True]//Timing

GraphData[{"Barbell",19},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",19},"VertexList"],GraphData[{"Barbell",19},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",19},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",19}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",19},"Matchstick"]

GraphData[{"Barbell",19},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",19},"Edges"]]

3D All

GraphData[{"Barbell",19},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",19},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",19},"Polyhedral"]

GraphData[{"Barbell",19},"Graph",{"3D","Polyhedron"}]

{"Barbell", 20}

Names

GraphData[{"Barbell",20},"StandardName"]

GraphData[{"Barbell",20},"StandardNames"]

Primary

GraphData[{"Barbell",20}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Barbell",20},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Barbell",20},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Barbell",20},"EdgeList"]]

Default embedding

BarbellGraph[{"Barbell",20}[[2]]]

GraphPlot@GraphData[{"Barbell",20},"Edges"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Barbell",20},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Barbell",20},"Graph","Degenerate"]

Configuration

GraphData[{"Barbell",20},"Configuration"]

GraphData[{"Barbell",20},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Barbell",20},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Barbell",20},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Barbell",20},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Barbell",20},"Graph","IGraph"]//StyleGraphs

Bilateral

gs=GraphData[{"Barbell",20},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Barbell",20},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,Left}}]

Circular

GraphData[{"Barbell",20},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Barbell",20},"Hamiltonian"]

GraphData[{"Barbell",20},"HamiltonianCycleCount"]

g=BarbellGraph[{"Barbell",20}[[2]],GraphLayout->"CircularEmbedding"]

Planar

GraphData[{"Barbell",20},"Planar"]

GraphData[{"Barbell",20},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Barbell",20},{"RCN","CN"}]

GraphData[{"Barbell",20},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Barbell",20}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",20}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",20}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",20}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",20}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Barbell",20}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Barbell",20}],"CrossingNumber"->cn])//PolyhedralGraphQ

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Barbell",20}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"Barbell",20},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Barbell",20}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Barbell",20},"LocalCrossingNumber"]

GraphData[{"Barbell",20},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Barbell",20}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",20}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Barbell",20}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Barbell",20},"Circulant"]

GraphData[{"Barbell",20},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Barbell",20},"ComplementGraph","Name"]

Line graph

GraphData[{"Barbell",20},"Line"]

LineGraphQ[GraphData[{"Barbell",20}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Barbell",20}&]

RootGraph[GraphData[{"Barbell",20}]]

RecognizeGraph[%]

Halin

GraphData[{"Barbell",20},"Halin"]

GraphData[{"Barbell",20},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Barbell",20},"Rigid"]

GraphData[{"Barbell",20},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Barbell",20},"Flexible"]

GraphData[{"Barbell",20},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Barbell",20},"LCF"]

GraphData[{"Barbell",20},"HamiltonianCycleCount"]

GraphData[{"Barbell",20},"LCFSignature"]

GraphData[{"Barbell",20},"LCFNotations"]

GraphData[{"Barbell",20},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Barbell",20},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Barbell",20}],Debug->True]//Timing

GraphData[{"Barbell",20},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Barbell",20},"VertexList"],GraphData[{"Barbell",20},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Barbell",20},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Barbell",20}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Barbell",20},"Matchstick"]

GraphData[{"Barbell",20},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Barbell",20},"Edges"]]

3D All

GraphData[{"Barbell",20},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Barbell",20},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Barbell",20},"Polyhedral"]

GraphData[{"Barbell",20},"Graph",{"3D","Polyhedron"}]

Properties

Acyclic

seq=Table[GraphData[{"Barbell",n},"Acyclic"],{n,3,20}]

AdjacencyMatrixCount

seq=Table[GraphData[{"Barbell",n},"AdjacencyMatrixCount"],{n,3,20}]

FullSimplify[(((2n)!)/(2Gamma[n]^2))]

Table[(((2n)!)/(2Gamma[n]^2)),{n,3,20}]

Arboricity

seq=Table[GraphData[{"Barbell",n},"Arboricity"],{n,3,20}]

Table[Ceiling[n/2],{n,3,20}]

ArcTransitive

seq=Table[GraphData[{"Barbell",n},"ArcTransitive"],{n,3,20}]

ArcTransitcivity

seq=Table[GraphData[{"Barbell",n},"ArcTransitivity"],{n,3,20}]

AutomorphismCount

seq=DeleteCases[GraphData[{"Barbell",#},"AutomorphismCount"]&/@Range[3,20],_Missing]

FindSequenceFunction[seq,n-2]//FunctionExpand

BalabanIndex

seq=Table[GraphData[{"Barbell",n},"BalabanIndex"],{n,3,6}]//FullSimplify

Bandwidth

seq=Table[GraphData[{"Barbell",n},"Bandwidth"],{n,3,20}]

BridgeCount

seq=Table[GraphData[{"Barbell",n},"BridgeCount"],{n,3,20}]

BurningNumber

seq=Table[GraphData[{"Barbell",n},"BurningNumber"],{n,3,20}]

CharacteristicPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"CharacteristicPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Chordal

seq=Table[GraphData[{"Barbell",n},"Chordal"],{n,3,20}]

ChordCount

seq=Table[GraphData[{"Barbell",n},"ChordCount"],{n,3,20}]

seq=Table[Piecewise[{{0,n==3}},2Binomial[n,2]],{n,3,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[Rest@seq,n-3]//Factor

Chordless

seq=Table[GraphData[{"Barbell",n},"Chordless"],{n,3,20}]

ChordlessCycleCount

seq=Table[GraphData[{"Barbell",n},"ChordlessCycleCount"],{n,3,20}]

Chords

seq=Table[GraphData[{"Barbell",n},"Chords"],{n,3,20}]

ChromaticallyUnique

seq=Table[GraphData[{"Barbell",n},"ChromaticallyUnique"],{n,20}]

GraphData[{"ChromaticallyUnique","Barbell"}]

ChromaticInvariant

seq=Table[GraphData[{"Barbell",n},"ChromaticInvariant"],{n,3,20}]

ChromaticNumber

seq=Table[GraphData[{"Barbell",n},"ChromaticNumber"],{n,3,20}]

ChromaticPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"ChromaticPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

poly2=Table[((FactorialPower[x,n])^2)(x-1)/x,{n,k0,kmax}];

FullSimplify[poly2-poly]

Circumference

seq=Table[GraphData[{"Barbell",n},"Circumference"],{n,3,20}]

Classes

Intersection@@(GraphData[#,"Classes"]&/@GraphData["Barbell"])

CliqueCount

seq=Table[GraphData[{"Barbell",n},"CliqueCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

CliqueCoveringNumber

seq=Table[GraphData[{"Barbell",n},"CliqueCoveringNumber"],{n,3,20}]

CliqueNumber

seq=Table[GraphData[{"Barbell",n},"CliqueNumber"],{n,3,20}]

CliquePolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"CliquePolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

CochromaticGraphNames

Table[GraphData[{"Barbell",n},"CochromaticGraphNames"],{n,3,20}]//Column

Select[GraphData["Barbell"],GraphData[#,"ChromaticallyUnique"]=!=False&]

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"Barbell",n},"ComplementOddChordlessCycleCount"],{n,3,20}]

ConnectedComponentCount

seq=Table[GraphData[{"Barbell",n},"ConnectedComponentCount"],{n,3,20}]

ConnectedDominatingSetCount

A000302

seq=Table[GraphData[{"Barbell",n},"ConnectedDominatingSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing[seq],n-2]

Table[(4^(n-1)),{n,3,10}]

ConnectedDominationNumber

Table[GraphData[{"Barbell",n},"ConnectedDominationNumber"],{n,3,20}]

ConnectedDominationPolynomial

(poly=Factor@Table[GraphData[{"Barbell",n},"ConnectedDominationPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,3,20}]

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

A290718

seq=Table[GraphData[{"Barbell",n},"ConnectedInducedSubgraphCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//FullSimplify

seq=Table[(2^(n+1))+(4^(n-1))-2,{n,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{7,-14,8},{3,10,30},40]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((-3+11 x-2 (x^2))/(-1+7 x-14 (x^2)+8 (x^3))),{x,0,20}],x]

ConnectedInducedSubgraphPolynomial

(poly=DeleteCases[Factor@Table[GraphData[{"Barbell",n},"ConnectedInducedSubgraphPolynomial"][x],{n,k0=3,20}],_Missing[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,3,20}]

FullSimplify[poly2-poly]

CrossingNumber

seq=Table[GraphData[{"Barbell",n},"CrossingNumber"],{n,3,20}]

CycleCount

A002807

seq=Table[GraphData[{"Barbell",n},"CycleCount"],{n,3,20}]

Table[Sum[Binomial[n,k] (k-1)!,{k,3,n}],{n,3,20}]

CyclePolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"CyclePolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

poly2=Table[ Sum[(\[FormalK]-1)! Binomial[n,\[FormalK]](x^\[FormalK]),{\[FormalK],3,n}],{n,k0,20}]

FullSimplify[poly2-poly]

Cyclic

Table[GraphData[{"Barbell",n},"Cyclic"],{n,3,20}]

CyclomaticNumber

seq=Table[GraphData[{"Barbell",n},"CyclomaticNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

DetourIndex

seq=Table[GraphData[{"Barbell",n},"DetourIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

DetourMatrix

MatrixForm/@Table[GraphData[{"Barbell",n},"DetourMatrix"],{n,3,20}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,3,20}]

DetourPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"DetourPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Diameter

seq=Table[GraphData[{"Barbell",n},"Diameter"],{n,3,20}]

DistanceMatrix

MatrixForm/@Table[GraphData[{"Barbell",n},"DistanceMatrix"],{n,3,20}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,3,20}]

DistancePolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"DistancePolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

DistinguishingNumber

Probably n-1

seq=Table[GraphData[{"Barbell",n},"DistinguishingNumber"],{n,3,20}]

DomaticNumber

seq=Table[GraphData[{"Barbell",n},"DomaticNumber"],{n,3,20}]

DominatingSetCount

A060867

seq=Table[GraphData[{"Barbell",n},"DominatingSetCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[(2^n-1)^2,{n,30}]

DominationNumber

seq=Table[GraphData[{"Barbell",n},"DominationNumber"],{n,3,10}]

DominationPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"DominationPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

CoefficientList[Take[poly,5],x]

coef=Factor/@FindLinearRecurrence[poly]

p=.

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

EdgeChromaticNumber

seq=Table[GraphData[{"Barbell",n},"EdgeChromaticNumber"],{n,3,20}]

EdgeConnectivity

Table[GraphData[{"Barbell",n},"EdgeConnectivity"],{n,3,20}]

EdgeCount

seq=Table[GraphData[{"Barbell",n},"EdgeCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

EdgeCoverCount

seq=Table[GraphData[{"Barbell",n},"EdgeCoverCount"],{n,3,20}]

FindLinearRecurrence[DeleteMissing[seq]]

FindSequenceFunction[DeleteMissing[seq],n-2]

gf=x FindGeneratingFunction[DeleteMissing[seq],x]

g=GraphData[{"Barbell",3},"Graph","Labeled"]

GraphData[{"Barbell",3},"MinimumEdgeCovers"]/.Thread[Range[EdgeCount[g]]->EdgeList[g]]

g=GraphData[{"Barbell",4},"Graph","Labeled"]

GraphData[{"Barbell",4},"EdgeCount"]

GraphData[{"Barbell",4},"EdgeList"]

GraphData[{"Barbell",4},"MinimumEdgeCovers"]

GraphData[{"Barbell",4},"MinimumEdgeCovers"]/.i_Integer:>EdgeList[g][[i]]

Select[Subsets[EdgeList[g],{4}],EdgeCoverQ[g,#]&]

Length[%]

GraphData[{"Barbell",4},"EdgeCoverCount"]

GraphData[{"Barbell",4},"MinimumEdgeCoverCount"]

EdgeCoverNumber

seq=Table[GraphData[{"Barbell",n},"EdgeCoverNumber"],{n,3,20}]

EdgeCoverPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"EdgeCoverPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

EulerianCycleCount

seq=Table[GraphData[{"Barbell",n},"EulerianCycleCount"],{n,3,20}]

FaceCount

seq=Table[GraphData[{"Barbell",n},"FaceCount"],{n,3,20}]

FlowPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"FlowPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])

FractionalChromaticNumber

seq=Table[GraphData[{"Barbell",n},"FractionalChromaticNumber"],{n,3,20}]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"Barbell",n},"FractionalEdgeChromaticNumber"],{n,3,20}]

Girth

seq=Table[GraphData[{"Barbell",n},"Girth"],{n,3,20}]

Gonality

seq=Table[GraphData[{"Barbell",n},"Gonality"],{n,3,20}]

HamiltonConnected

seq=Table[GraphData[{"Barbell",n},"HamiltonConnected"],{n,3,20}]

HamiltonDecompositionCount

seq=Table[GraphData[{"Barbell",n},"HamiltonDecompositionCount"],{n,3,20}]

Hamiltonian

Table[GraphData[{"Barbell",n},"Hamiltonian"],{n,3,20}]

HamiltonianCycleCount

seq=Table[GraphData[{"Barbell",n},"HamiltonianCycleCount"],{n,3,20}]

HamiltonianNumber

Probably 2(n+1)

seq=Table[GraphData[{"Barbell",n},"HamiltonianNumber"],{n,3,20}]

HamiltonianPathCount

seq=Table[GraphData[{"Barbell",n},"HamiltonianPathCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FunctionExpand

Table[Gamma[n]^2,{n,3,20}]

HamiltonianWalkCount

seq=Table[GraphData[{"Barbell",n},"HamiltonianWalkCount"],{n,3,20}]

HararyIndex

seq=Table[GraphData[{"Barbell",n},"HararyIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

HexagonCount

seq=Table[GraphData[{"Barbell",n},"HexagonCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

5!Binomial[n,6]//FunctionExpand

IdiosyncraticPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"IdiosyncraticPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

IndependenceNumber

seq=Table[GraphData[{"Barbell",n},"IndependenceNumber"],{n,3,20}]

IndependencePolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"IndependencePolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

IndependenceRatio

seq=Table[GraphData[{"Barbell",n},"IndependenceRatio"],{n,3,20}]

FindSequenceFunction[seq,n-2]

IndependentEdgeSetCount

A288841

Entity["Graph",{"Complete",n}]["IndependentEdgeSetCount"]

seq=Table[GraphData[{"Barbell",n},"IndependentEdgeSetCount"],{n,3,20}]

seq=Table[((((I/Sqrt[2])^n HermiteH[n,-I/Sqrt[2]]))^2)+((((I/Sqrt[2])^(n-1) HermiteH[n-1,-I/Sqrt[2]]))^2),{n,30}]

FullSimplify[((((I/Sqrt[2])^n HermiteH[n,-I/Sqrt[2]]))^2)+((((I/Sqrt[2])^(n-1) HermiteH[n-1,-I/Sqrt[2]]))^2),n∈Integers&&n>2]

FullSimplify[((((I/Sqrt[2])^n HermiteH[n,-I/Sqrt[2]]))^2)+((((I/Sqrt[2])^(n-1) HermiteH[n-1,-I/Sqrt[2]]))^2),n∈Integers]

Table[(((-(1/2)))^n) (((HermiteH[n,-(I/(Sqrt[2]))])^2)-2 ((HermiteH[-1+n,-(I/(Sqrt[2]))])^2)),{n,20}]

FullSimplify[(((HypergeometricU[-n/2,1/2,-1/2]/(-1/2)^(n/2)))^2)+(((HypergeometricU[-(n-1)/2,1/2,-1/2]/(-1/2)^((n-1)/2)))^2),n∈Integers]

Table[(((-2))^(n-2)) (((HypergeometricU[1-(n/2),(3/2),-(1/2)])^2)+4 ((HypergeometricU[-(n/2),(1/2),-(1/2)])^2)),{n,20}]

FindLinearRecurrence[DeleteMissing[seq]]

FindLinearRecurrence[Drop[DeleteMissing[seq],2]]

gf=(x^3)FindGeneratingFunction[DeleteMissing[seq],x]

IndependentVertexSetCount

A005563

seq=Table[GraphData[{"Barbell",n},"IndependentVertexSetCount"],{n,3,20}]

FindLinearRecurrence[seq]

seq=LinearRecurrence[{3,-3,1},{3,8,15},{0,20}]

seq=LinearRecurrence[{3,-3,1},{3,8,15},20]

gf=x FindGeneratingFunction[seq,x]//Factor

CoefficientList[Series[(((-3+x) x)/(((-1+x))^3)),{x,0,20}],x]

FindSequenceFunction[seq,n-2]//Simplify

Table[n^2-1,{n,42}]

Range[20]^2-1

IntersectionNumber

seq=Table[GraphData[{"Barbell",n},"IntersectionNumber"],{n,3,20}]

IrredundancePolynomial

(poly=DeleteMissing@Table[GraphData[{"Barbell",n},"IrredundancePolynomial"]/.f_Function:>f[x],{n,3,20}])//Column

Table[1+2n x+(n^2)(x^2),{x,3,20}]//Column

IrredundantSetCount

seq=Table[GraphData[{"Barbell",n},"IrredundantSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Factor

KirchhoffIndex

seq=Table[GraphData[{"Barbell",n},"KirchhoffIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

KirchhoffSumIndex

seq=Table[GraphData[{"Barbell",n},"KirchhoffSumIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

LaplacianMatrix

MatrixForm/@Table[GraphData[{"Barbell",n},"LaplacianMatrix"],{n,3,20}]

LaplacianPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"LaplacianPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

(poly2=Table[(((x-n))^(2n-3))x(2-(n+2)x+(x^2)),{n,k0,kmax}])//Column

FullSimplify[poly2-poly]

LeafCount

seq=Table[GraphData[{"Barbell",n},"LeafCount"],{n,3,20}]

LongestCycleCount

seq=Table[GraphData[{"Barbell",n},"LongestCycleCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FunctionExpand

LovaszNumber

seq=Table[GraphData[{"Barbell",n},"LovaszNumber"],{n,3,20}]

MatchingGeneratingPolynomial

Entity["Graph",{"Complete",n}]["MatchingGeneratingPolynomial"]

bug(335931)

Entity["Graph",{"Complete",n}]["MatchingGeneratingPolynomial"][x]

(poly=Factor[Table[GraphData[{"Barbell",n},"MatchingGeneratingPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

Table[FindSequenceFunction[Coefficient[poly,x,k],n],{k,0,6}]//Factor//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

MatchingNumber

seq=Table[GraphData[{"Barbell",n},"MatchingNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

MatchingPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"MatchingPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

CoefficientList[Take[poly,5][[All,1]],x]

coef1=Factor/@FindLinearRecurrence[DeleteMissing@poly[[All,1]]]

coef2=Factor/@FindLinearRecurrence[DeleteMissing@poly[[All,2]]]

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

MaximalCliqueCount

seq=Table[GraphData[{"Barbell",n},"MaximalCliqueCount"],{n,3,20}]

MaximalIndependentEdgeSetCount

seq=Table[GraphData[{"Barbell",n},"MaximalIndependentEdgeSetCount"],{n,3,20}]

Table[Piecewise[{{2((n-1)!!)^2,Mod[n,2]==0},{(n!!)^2,Mod[n,2]==1}}],{n,3,20}]

MaximalIndependentEdgeSetSignature

seq=Table[GraphData[{"Barbell",n},"MaximalIndependentEdgeSetSignature"],{n,3,20}]

seq[[1;;8;;2]]

Divide@@@seq[[1;;8;;2]][[All,All,2]]

FindSequenceFunction[%,n]//Factor

Table[4 n (1+n),{n,4}]

Table[4 (n-1)/2(1+(n-1)/2),{n,3,10,2}]

Simplify[4 (n-1)/2(1+(n-1)/2)]

Table[{{n-1,((n^2)-1)(((n-2)!!)^2)},{n,((n-2)!!)^2}},{n,3,10,2}]

seq[[2;;7;;2]][[All,All,2]][[All,1]]

Table[((n-1)!!)^2,{n,2,8,2}]

Table[Piecewise[{
{{{n-1,((n-1)!!)^2},{n,((n-1)!!)^2}},Mod[n,2]==0},
{{{n-1,((n^2)-1)(((n-2)!!)^2)},{n,((n-2)!!)^2}},Mod[n,2]==1}}],{n,3,9}]

%==DeleteMissing@seq

Table[Piecewise[{
{{{n-1,((n-1)!!)^2},{n,((n-1)!!)^2}},Mod[n,2]==0},
{{{n-1,((n^2)-1)(((n-2)!!)^2)},{n,((n-2)!!)^2}},Mod[n,2]==1}}][[All,2]]//Total,{n,3,20}]

MaximalIndependentVertexSetCount

seq=Table[GraphData[{"Barbell",n},"MaximalIndependentVertexSetCount"],{n,3,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-2]//Simplify

MaximalIrredundantSetCount

seq=Table[GraphData[{"Barbell",n},"MaximalIrredundantSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Factor

MaximumCliqueCount

seq=Table[GraphData[{"Barbell",n},"MaximumCliqueCount"],{n,3,20}]

MaximumIndependentEdgeSetCount

seq=Table[GraphData[{"Barbell",n},"MaximumIndependentEdgeSetCount"],{n,3,20}]

seq2=DeleteMissing@seq[[2;;All;;2]]

FindLinearRecurrence[seq2]

FindSequenceFunction[seq2,n]

Table[((2Floor[n/2]-1)!!)^2,{n,3,20}]

MaximumIndependentVertexSetCount

seq=Table[GraphData[{"Barbell",n},"MaximumIndependentVertexSetCount"],{n,3,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-2]//Simplify

MaximumIrredundantSetCount

seq=Table[GraphData[{"Barbell",n},"MaximumIrredundantSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Simplify

MaximumLeafNumber

seq=Table[GraphData[{"Barbell",n},"MaximumLeafNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

MaximumVertexDegree

seq=Table[GraphData[{"Barbell",n},"MaximumVertexDegree"],{n,3,20}]

MeanDistance

seq=Table[GraphData[{"Barbell",n},"MeanDistance"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

MinimalDominatingSetCount

seq=Table[GraphData[{"Barbell",n},"MinimalDominatingSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Factor

MinimalDominatingSetSignature

seq=Table[GraphData[{"Barbell",n},"MinimalDominatingSetSignature"],{n,3,20}]

MinimalEdgeCoverCount

A290715

seq=Table[GraphData[{"Barbell",n},"MinimalEdgeCoverCount"],{n,3,20}]

Table[GraphData[{"Barbell",n},"EdgeCoverCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Factor

MinimumCliqueCoveringCount

seq=Table[GraphData[{"Barbell",n},"MinimumCliqueCoveringCount"],{n,3,20}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"Barbell",n},"MinimumConnectedDominatingSetCount"],{n,3,20}]

MinimumDominatingSetCount

seq=Table[GraphData[{"Barbell",n},"MinimumDominatingSetCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Simplify

MinimumEdgeCoverCount

seq=Table[GraphData[{"Barbell",n},"MinimumEdgeCoverCount"],{n,3,20}]

{1,3,3,15,15}^2?

Table[(2n-1)!!,{n,4}]

105^2

MinimumVertexDegree

seq=Table[GraphData[{"Barbell",n},"MinimumVertexDegree"],{n,3,20}]

MolecularTopologicalIndex

seq=Table[GraphData[{"Barbell",n},"MolecularTopologicalIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

FindGeneratingFunction[seq,x]//Facto

Nonhamiltonian

Table[GraphData[{"Barbell",n},"Nonhamiltonian"],{n,3,20}]

NormalizedLaplacianMatrix

MatrixForm/@Table[GraphData[{"Barbell",n},"NormalizedLaplacianMatrix"],{n,3,20}]

OddChordlessCycleCount

seq=Table[GraphData[{"Barbell",n},"OddChordlessCycleCount"],{n,3,20}]

PathCount

A288703

seq=Table[GraphData[{"Barbell",n},"PathCount"],{n,3,20}]

sum(i=0,n,n!/i!);

Sum[n!/i!,{i,0,n}]//FullSimplify

Table[(((E Gamma[n,1]))^2)+E Gamma[1+n,1]-n-1,{n,20}]

FullSimplify[(E^2) ((Gamma[n,1])^2)+E Gamma[1+n,1]-n-1]

Table[E (E ((Gamma[n,1])^2)+Gamma[1+n,1])-n-1,{n,20}]

FindLinearRecurrence[DeleteMissing@seq]

FindSequenceFunction[DeleteMissing@seq,n-2]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

PathPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"PathPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

PentagonCount

seq=Table[GraphData[{"Barbell",n},"PentagonCount"],{n,3,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-2]//Factor

Perfect

Table[GraphData[{"Barbell",n},"Perfect"],{n,3,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"Barbell",n},"ProjectivePlaneCrossingNumber"],{n,3,20}]

Radius

seq=Table[GraphData[{"Barbell",n},"Radius"],{n,3,20}]

RankPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"RankPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"Barbell",n},"RectilinearCrossingNumber"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]

ReliabilityPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"ReliabilityPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

SigmaPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"SigmaPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

SpanningTreeCount

A193129

seq=Table[GraphData[{"Barbell",n},"SpanningTreeCount"],{n,3,20}]

Table[n^(2n-4),{n,3,20}]

SquareCount

seq=Table[GraphData[{"Barbell",n},"SquareCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

StabilityIndex

seq=Table[GraphData[{"Barbell",n},"StabilityIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify//Factor

TopologicalIndex

seq=Table[GraphData[{"Barbell",n},"TopologicalIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

ToroidalCrossingNumber

seq=Table[GraphData[{"Barbell",n},"ToroidalCrossingNumber"],{n,3,20}]

Traceable

Table[GraphData[{"Barbell",n},"Traceable"],{n,3,20}]

TriangleCount

seq=Table[GraphData[{"Barbell",n},"TriangleCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

TuttePolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"TuttePolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Untraceable

Table[GraphData[{"Barbell",n},"Untraceable"],{n,3,20}]

VertexConnectivity

Table[GraphData[{"Barbell",n},"VertexConnectivity"],{n,3,20}]

VertexCount

seq=Table[GraphData[{"Barbell",n},"VertexCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

VertexCoverNumber

vertex cover number == vertex count - independence number

seq=Table[GraphData[{"Barbell",n},"VertexCoverNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

VertexCoverPolynomial

(poly=Factor[Table[GraphData[{"Barbell",n},"VertexCoverPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

VertexDegrees

seq=Table[GraphData[{"Barbell",n},"VertexDegrees"],{n,3,20}]

VertexTransitive

Table[GraphData[{"Barbell",n},"VertexTransitive"],{n,3,20}]

WienerIndex

seq=Table[GraphData[{"Barbell",n},"WienerIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

WienerSumIndex

seq=Table[GraphData[{"Barbell",n},"WienerSumIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

GraphData

GraphClassString

GraphClassString[Select[GraphData["Barbell"],GraphData[#,"V"]>0&]]

GraphDataString

Do[Print[GraphDataString[BarbellGraph[n],{{"Barbell",n},ToString[n]<>"-barbell graph","BarbellGraph"},Debug->True,TimeConstraint->60]],{n,4,20}]