Hexagonal Grid Graph

Author

Eric W. Weisstein
February 24, 2023

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

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

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

Figure

n×n×n

GraphicsRow[Table[Show[GraphData[{"HexagonalGrid",{n,n,n}}]//StyleGraphs,PlotLabel->Style[Row[Riffle[{n,n,n},"×"]],Directive[Black,14,FontFamily->"Times"]]],{n,4}]]

k×m×n

GraphicsGrid[Partition[StyleGraphs@HexagonalGridGraph[#,PlotLabel->Style[Row[Riffle[#,"×"]],Black]]&/@Union[Sort/@Tuples[Range[4],{3}]],6],Dividers->All,ImageSize->500]

k×m×1

GraphicsGrid[Partition[StyleGraphs@HexagonalGridGraph[#,PlotLabel->Row[Riffle[#,"×"]]]&/@(Append[#,1]&/@Union[Sort/@Tuples[Range[5],{2}]]),6],Dividers->All,ImageSize->500]

Embeddings

<<MathWorld`Graphs`

GraphData["HexagonalGrid*"]

{"HexagonalGrid", {1, 1, 1}} == {"Cycle", 6}

GraphData[{"HexagonalGrid",{1,1,1}},"StandardName"]

{"HexagonalGrid", {1, 1, 2}}

GraphData[{"HexagonalGrid",{1,1,2}},"StandardName"]

Primary

GraphData[{"HexagonalGrid",{1,1,2}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HexagonalGrid",{1,1,2}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HexagonalGrid",{1,1,2}},"Edges"]

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

RecognizeGraph[g]

v={2#,#2}&@@@{{0,0},{1/2,0},{1,0},{1,1},{1/2,1},{0,1},{-1/2,1},{-1,1},{-1,0},{-1/2,0}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,10},1,6]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

UnitDistanceGraphEmbeddingQ@g

RotateGraph[Graph[GraphData[{"HexagonalGrid",{1,1,2}},"Edges"],GraphLayout->"LayeredDigraphEmbedding"],Pi/2]

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

RecognizeGraph@g

Degenerate

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Degenerate"]

Bilateral

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Circular"]//StyleGraphs

Circular construction

Length[hc=FindHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,2}}],All][[All,All,1]]]

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph@CircularEmbeddingFromHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,2}}],#]&/@hc],
CircularCanonicalGraphEmbedding]]//Quiet//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]//Quiet

quad

Planar

GraphData[{"HexagonalGrid",{1,1,2}},"Planar"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"HexagonalGrid",{1,1,2}},{"RCN","CN"}]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

MinimalCrossingGraph[GraphData[{"HexagonalGrid",{1,1,2}}]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HexagonalGrid",{1,1,2}},"Circulant"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"HexagonalGrid",{1,1,2}},"Halin"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"HexagonalGrid",{1,1,2}},"Rigid"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HexagonalGrid",{1,1,2}},"Flexible"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"HexagonalGrid",{1,1,2}},"LCF"]

GraphData[{"HexagonalGrid",{1,1,2}},"HamiltonianCycleCount"]

GraphData[{"HexagonalGrid",{1,1,2}},"LCFSignature"]

GraphData[{"HexagonalGrid",{1,1,2}},"LCFNotations"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","LCF"]//StyleGraphs

UnitDistance

GraphData[{"HexagonalGrid",{1,1,2}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"HexagonalGrid",{1,1,2}}],Debug->True]//Timing

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"HexagonalGrid",{1,1,2}},"VertexList"],GraphData[{"HexagonalGrid",{1,1,2}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,1,2}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,1,2}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"HexagonalGrid",{1,1,2}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,1,2}}],TimeConstraint->300,"Results"->All]//Timing}

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

gs={,,,RotateGraph[,{11,1}]}

gs={,,,,,,,,,,,RotateGraph[,Pi/2]}

gs={,,,,,,,,RotateGraph[,-Pi/4-Pi/2],RotateGraph[,{3,16}],,,,RotateGraph[,{1,18}],,,}

Matchstick

GraphData[{"HexagonalGrid",{1,1,2}},"Matchstick"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"HexagonalGrid",{1,1,2}},"Edges"]]

3D All

GraphData[{"HexagonalGrid",{1,1,2}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"HexagonalGrid",{1,1,2}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"HexagonalGrid",{1,1,2}},"Polyhedral"]

GraphData[{"HexagonalGrid",{1,1,2}},"Graph",{"3D","Polyhedron"}]

{"HexagonalGrid", {1, 1, 3}}

GraphData[{"HexagonalGrid",{1,1,3}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HexagonalGrid",{1,1,3}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HexagonalGrid",{1,1,3}},"Edges"]

v={{0,0},{1/2,0},{1,0},{3/2,0},{2,0},{5/2,0},{3,0},{3,1},{5/2,1},{2,1},{3/2,1},{1,1},{1/2,1},{0,1}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,14},1],{3,12},{5,10}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

v={2#,#2}&@@@{{0,0},{1/2,0},{1,0},{3/2,0},{2,0},{5/2,0},{3,0},{3,1},{5/2,1},{2,1},{3/2,1},{1,1},{1/2,1},{0,1}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,14},1],{3,12},{5,10}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

UnitDistanceGraphEmbeddingQ@g

RotateGraph[Graph[GraphData[{"HexagonalGrid",{1,1,3}},"Edges"],GraphLayout->"LayeredDigraphEmbedding"],Pi/2]

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

RecognizeGraph[g]

gs={,};

Degenerate

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

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

Bilateral

GraphData[{"HexagonalGrid",{1,1,3}},"Graph","Bilateral"]//StyleGraphs

Circular

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

Circular construction

Length[hc=FindHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,3}}],All][[All,All,1]]]

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph@CircularEmbeddingFromHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,3}}],#]&/@hc],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"HexagonalGrid",{1,1,3}},"Planar"]

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

MinimalCrossing

GraphData[{"HexagonalGrid",{1,1,3}},{"RCN","CN"}]

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

MinimalCrossing construction

MinimalCrossingGraph[GraphData[{"HexagonalGrid",{1,1,3}}]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HexagonalGrid",{1,1,3}},"Circulant"]

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

Halin

GraphData[{"HexagonalGrid",{1,1,3}},"Halin"]

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

Rigid

GraphData[{"HexagonalGrid",{1,1,3}},"Rigid"]

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

Flexible

GraphData[{"HexagonalGrid",{1,1,3}},"Flexible"]

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

LCF

GraphData[{"HexagonalGrid",{1,1,3}},"LCF"]

GraphData[{"HexagonalGrid",{1,1,3}},"HamiltonianCycleCount"]

GraphData[{"HexagonalGrid",{1,1,3}},"LCFSignature"]

GraphData[{"HexagonalGrid",{1,1,3}},"LCFNotations"]

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

UnitDistance

GraphData[{"HexagonalGrid",{1,1,3}},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

gs={,,,,,,,,,,,,,,,,RotateGraph[,{13,7}],,};

Matchstick

GraphData[{"HexagonalGrid",{1,1,3}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"HexagonalGrid",{1,1,3}},"Edges"]]

3D All

GraphData[{"HexagonalGrid",{1,1,3}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"HexagonalGrid",{1,1,3}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"HexagonalGrid",{1,1,3}},"Polyhedral"]

GraphData[{"HexagonalGrid",{1,1,3}},"Graph",{"3D","Polyhedron"}]

{"HexagonalGrid", {1, 1, 4}}

GraphData[{"HexagonalGrid",{1,1,4}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HexagonalGrid",{1,1,4}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HexagonalGrid",{1,1,4}},"Edges"]

v=Join[Table[{i,0},{i,0,8}],Table[{i,1},{i,8,0,-1}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,18},1],{3,16},{5,14},{7,12}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

UnitDistanceGraphEmbeddingQ@g

v={#/2,#2}&@@@Join[Table[{i,0},{i,0,8}],Table[{i,1},{i,8,0,-1}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,18},1],{3,16},{5,14},{7,12}},VertexCoordinates->v,VertexLabels->Automatic]

UnitDistanceGraphEmbeddingQ@g

gs={,};

Degenerate

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

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

Bilateral

GraphData[{"HexagonalGrid",{1,1,4}},"Graph","Bilateral"]//StyleGraphs

Circular

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

Circular construction

Length[hc=FindHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,4}}],All][[All,All,1]]]

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph@CircularEmbeddingFromHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,4}}],#]&/@hc],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"HexagonalGrid",{1,1,4}},"Planar"]

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

MinimalCrossing

GraphData[{"HexagonalGrid",{1,1,4}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"HexagonalGrid",{1,1,4}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HexagonalGrid",{1,1,4}},"Circulant"]

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

Circulant construction

CirculantGraph1@@@CirculantIndices[GraphData[{"HexagonalGrid",{1,1,4}}]]

gs=CirculantGraph1@@@Cases[GraphData[{"HexagonalGrid",{1,1,4}},"StandardNames"],{"Circulant",i_}:>i]

Halin

GraphData[{"HexagonalGrid",{1,1,4}},"Halin"]

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

Rigid

GraphData[{"HexagonalGrid",{1,1,4}},"Rigid"]

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

Flexible

GraphData[{"HexagonalGrid",{1,1,4}},"Flexible"]

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

LCF

GraphData[{"HexagonalGrid",{1,1,4}},"LCF"]

GraphData[{"HexagonalGrid",{1,1,4}},"HamiltonianCycleCount"]

GraphData[{"HexagonalGrid",{1,1,4}},"LCFSignature"]

GraphData[{"HexagonalGrid",{1,1,4}},"LCFNotations"]

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

UnitDistance

GraphData[{"HexagonalGrid",{1,1,4}},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"HexagonalGrid",{1,1,4}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,1,4}}],TimeConstraint->300,"Results"->All]//Timing}

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

gs={,,,,,,,,RotateGraph[,{13,9}],,,,,,,,,,,};

Matchstick

GraphData[{"HexagonalGrid",{1,1,4}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"HexagonalGrid",{1,1,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"HexagonalGrid",{1,1,4}},"Polyhedral"]

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

{"HexagonalGrid", {1, 1, 5}}

GraphData[{"HexagonalGrid",{1,1,5}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HexagonalGrid",{1,1,5}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HexagonalGrid",{1,1,5}},"Edges"]

v=Join[Table[{i,0},{i,0,10}],Table[{i,1},{i,10,0,-1}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,22},1],{3,20},{5,18},{7,16},{9,14}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

v={#/2,#2}&@@@Join[Table[{i,0},{i,0,10}],Table[{i,1},{i,10,0,-1}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,22},1],{3,20},{5,18},{7,16},{9,14}},VertexCoordinates->v,VertexLabels->Automatic]

gs={,};

Degenerate

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

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

Bilateral

GraphData[{"HexagonalGrid",{1,1,5}},"Graph","Bilateral"]//StyleGraphs

Circular

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

Circular construction

Length[hc=FindHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,5}}],All][[All,All,1]]]

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph@CircularEmbeddingFromHamiltonianCycle[GraphData[{"HexagonalGrid",{1,1,5}}],#]&/@hc],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"HexagonalGrid",{1,1,5}},"Planar"]

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

MinimalCrossing

GraphData[{"HexagonalGrid",{1,1,5}},{"RCN","CN"}]

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

MinimalCrossing construction

MinimalCrossingGraph[GraphData[{"HexagonalGrid",{1,1,5}}]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HexagonalGrid",{1,1,5}},"Circulant"]

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

Halin

GraphData[{"HexagonalGrid",{1,1,5}},"Halin"]

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

Rigid

GraphData[{"HexagonalGrid",{1,1,5}},"Rigid"]

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

Flexible

GraphData[{"HexagonalGrid",{1,1,5}},"Flexible"]

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

LCF

GraphData[{"HexagonalGrid",{1,1,5}},"LCF"]

GraphData[{"HexagonalGrid",{1,1,5}},"HamiltonianCycleCount"]

GraphData[{"HexagonalGrid",{1,1,5}},"LCFSignature"]

GraphData[{"HexagonalGrid",{1,1,5}},"LCFNotations"]

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

UnitDistance

GraphData[{"HexagonalGrid",{1,1,5}},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,1,5}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"HexagonalGrid",{1,1,5}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,1,5}}],TimeConstraint->300,"Results"->All]//Timing}

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

gs={,,,,,,,,,,,,,,,,,,,};

Matchstick

GraphData[{"HexagonalGrid",{1,1,5}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"HexagonalGrid",{1,1,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"HexagonalGrid",{1,1,5}},"Polyhedral"]

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

{"HexagonalGrid", {1, 2, 2}}

GraphData[{"HexagonalGrid",{1,2,2}},"StandardName"]

Primary

GraphData[{"HexagonalGrid",{1,2,2}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HexagonalGrid",{1,2,2}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HexagonalGrid",{1,2,2}},"Edges"]

v=Join[Subdivide[{0,0},{1,0},5],{{1,1/2}},Subdivide[{1,1},{0,1},5],{{0,1/2},{1/5,1/2},{4/5,1/2}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,14},1],e[2,15,12],e[5,16,9],{15,16}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

g=RotateGraph[Graph[GraphData[{"HexagonalGrid",{1,2,2}},"Edges"],GraphLayout->"LayeredDigraphEmbedding"],-Pi/2]

MinimalCrossingGraph[GraphData[{"HexagonalGrid",{1,2,2}}]]

v[[6,2]]

v=Join[CirclePoints[{1,Pi/2},14],{0,# Sin[((3π)/14)]}&/@{-1,1}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,14},1],e[6,15,10],e[3,16,13],{15,16}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

gs={,,};

Degenerate

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Degenerate"]

Bilateral

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"HexagonalGrid",{1,2,2}},"Planar"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"HexagonalGrid",{1,2,2}},{"RCN","CN"}]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

MinimalCrossingGraph[GraphData[{"HexagonalGrid",{1,2,2}}]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HexagonalGrid",{1,2,2}},"Circulant"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"HexagonalGrid",{1,2,2}},"Halin"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"HexagonalGrid",{1,2,2}},"Rigid"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HexagonalGrid",{1,2,2}},"Flexible"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"HexagonalGrid",{1,2,2}},"LCF"]

GraphData[{"HexagonalGrid",{1,2,2}},"HamiltonianCycleCount"]

GraphData[{"HexagonalGrid",{1,2,2}},"LCFSignature"]

GraphData[{"HexagonalGrid",{1,2,2}},"LCFNotations"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","LCF"]//StyleGraphs

UnitDistance

GraphData[{"HexagonalGrid",{1,2,2}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"HexagonalGrid",{1,2,2}}],Debug->True]//Timing

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"HexagonalGrid",{1,2,2}},"VertexList"],GraphData[{"HexagonalGrid",{1,2,2}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,2,2}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,2,2}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"HexagonalGrid",{1,2,2}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"HexagonalGrid",{1,2,2}}],TimeConstraint->300,"Results"->All]//Timing}

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

gs={,,,,,,,,,,,,};

Matchstick

GraphData[{"HexagonalGrid",{1,2,2}},"Matchstick"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"HexagonalGrid",{1,2,2}},"Edges"]]

3D All

GraphData[{"HexagonalGrid",{1,2,2}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"HexagonalGrid",{1,2,2}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"HexagonalGrid",{1,2,2}},"Polyhedral"]

GraphData[{"HexagonalGrid",{1,2,2}},"Graph",{"3D","Polyhedron"}]

GraphData

hex=GraphData["HexagonalGrid"]

TextGrid[{#,GraphData[#,"Graph","All"]}&/@Take[hex,5],Dividers->All]

Properties

Acyclic

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Acyclic"],{n,5}]

AdjacencyMatrixCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"AdjacencyMatrixCount"],{n,5}]

FindSequenceFunction[seq,n]//Head

AlgebraicConnectivity

Table[GraphData[{"HexagonalGrid",{n,n,n}},"AlgebraicConnectivity"],{n,5}]

Arboricity

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Arboricity"],{n,5}]

ArcTransitive

Table[GraphData[{"HexagonalGrid",{n,n,n}},"ArcTransitive"],{n,5}]

ArcTransitivity

Table[GraphData[{"HexagonalGrid",{n,n,n}},"ArcTransitivity"],{n,5}]

ArticulationVertexCount

Table[GraphData[{"HexagonalGrid",{n,n,n}},"ArticulationVertexCount"],{n,5}]

AutomorphismCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"AutomorphismCount"],{n,5}]

BalabanIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"BalabanIndex"],{n,5}]

FindSequenceFunction[seq,n]//Factor

Bandwidth

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Bandwidth"],{n,5}]

BipartiteDimension

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"BipartiteDimension"],{n,5}]

BridgeCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"BridgeCount"],{n,5}]

BurningNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"BurningNumber"],{n,5}]

CharacteristicPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"CharacteristicPolynomial"][x],{n,k0=1,5}])//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[(((-1-x))^(-1+n)) (-1+n-x),{n,k0,20}]

FullSimplify[poly2-poly]

CheegerConstant

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CheegerConstant"],{n,5}]

ChordCount

Table[GraphData[{"HexagonalGrid",{n,n,n}}],{n,3}]

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ChordCount"],{n,5}]

FindSequenceFunction[seq,n]//Factor

2x2x2

deg2=Position[GraphData[{"HexagonalGrid",{2,2,2}},"VertexDegrees"],2]//Flatten

HighlightGraph[g=GraphData[{"HexagonalGrid",{2,2,2}},"Graph","Labeled"],deg2]

border=Select[EdgeList[g],!FreeQ[#,Alternatives@@deg2]&]

HighlightGraph[g,border]

chords=Complement[EdgeList[g],border]

Length[chords]

3x3x3

deg2=Position[GraphData[{"HexagonalGrid",{3,3,3}},"VertexDegrees"],2]//Flatten

HighlightGraph[g=GraphData[{"HexagonalGrid",{3,3,3}},"Graph","Labeled"],deg2]

border=Select[EdgeList[g],!FreeQ[#,Alternatives@@deg2]&]

HighlightGraph[g,border]

chords=Complement[EdgeList[g],border]

Length[chords]

General

HexagonalGridGraphChords[g_System`Graph]:=Module[{deg2=Position[VertexDegree[g],2]//Flatten,border},
border=Select[EdgeList[g],!FreeQ[#,Alternatives@@deg2]&];
Complement[EdgeList[g],border]
]

chords=HexagonalGridGraphChords[GraphData[{"HexagonalGrid",{3,3,3}}]]

HighlightGraph[g,chords]

HighlightGraph[g=GraphData[{"HexagonalGrid",{1,2,3}}],Style[HexagonalGridGraphChords[g],Directive[Darker@Green,Thick]]]

HighlightGraph[g=GraphData[{"HexagonalGrid",{1,1,5}},"Graph","Labeled"],Style[HexagonalGridGraphChords[g],Directive[Darker@Green,Thick]]]

FindChord[GraphData[{"HexagonalGrid",{1,1,5}}],All]

ChordlessCycleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ChordlessCycleCount"],{n,5}]

ChordlessCyclePolynomial

(seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ChordlessCyclePolynomial"]/.f_Function:>f[x],{n,5}])//Column

ChromaticInvariant

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ChromaticInvariant"],{n,5}]

FindSequenceFunction[Drop[seq,2],n-2]

ChromaticNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ChromaticNumber"],{n,5}]

ChromaticPolynomial

(seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ChromaticPolynomial"]/.f_Function:>f[x],{n,5}])//Column

FindSequenceFunction[DeleteMissing@seq,n]//Head

Circumference

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Circumference"],{n,5}]

FindSequenceFunction[seq,n]

gf=x Factor[FindGeneratingFunction[seq,x]]

SeriesCoefficient[((2 (-3+x) x (1+x+(x^2)))/(((-1+x))^3)),{x,0,n}]

Table[Piecewise[{{6n^2,n==1}},6n^2-2],{n,5}]

Classes

Intersection@@(GraphData[#,"Classes"]&/@Select[GraphData["HexagonalGrid"],Equal@@("HexagonalGrid"/.GraphData[#,"NotationRules"])&])

CliqueCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CliqueCount"],{n,5}]

FindSequenceFunction[seq,n]//Factor

CliqueCoveringNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CliqueCoveringNumber"],{n,5}]

FindSequenceFunction[seq,n]

CliqueNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CliqueNumber"],{n,5}]

CliquePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"CliquePolynomial"][x],{n,k0=1,5}])//Column

FindSequenceFunction[Coefficient[poly,x],n]

FindSequenceFunction[Coefficient[poly,x,2],n]//Factor

Coarseness

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Coarseness"],{n,5}]

CoboundaryPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"CoboundaryPolynomial"]/.f_Function:>f[x,y],{n,k0=1,kmax=5}])//Column

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ComplementOddChordlessCycleCount"],{n,5}]

ComplementOddChordlessCyclePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"ComplementOddChordlessCyclePolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])

Conductance

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Conductance"],{n,5}]

ConnectedComponentCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ConnectedComponentCount"],{n,5}]

ConnectedDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ConnectedDominatingSetCount"],{n,5}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedDominationNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ConnectedDominationNumber"],{n,5}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedDominationPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"ConnectedDominationPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//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,5}]

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ConnectedInducedSubgraphCount"],{n,5}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedInducedSubgraphPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"ConnectedInducedSubgraphPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//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,5}]

FullSimplify[poly2-poly]

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CrossingNumber"],{n,5}]

Corank

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Corank"],{n,5}]

FindSequenceFunction[seq,n]//Factor

CrossingNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CrossingNumber"],{n,5}]

CycleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CycleCount"],{n,5}]

FindSequenceFunction[Drop[seq,2],n-2]

FindGeneratingFunction[seq,x]

CyclePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"CyclePolynomial"],{n,k0=1,kmax=5}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

CoefficientList[poly,x]

Cyclic

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Cyclic"],{n,5}]

CyclomaticNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"CyclomaticNumber"],{n,5}]

FindSequenceFunction[seq,n]//Factor

DetourIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"DetourIndex"],{n,5}]

FindSequenceFunction[seq,n]//Factor

DetourPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"DetourPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

coef=Factor/@FindLinearRecurrence[poly]

Diameter

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Diameter"],{n,5}]

FindSequenceFunction[seq,n]

Dimension

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Dimension"],{n,5}]

DistancePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"DistancePolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//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]

Table[n x(3x+2)-2x^2+1,{n,10}]

FullSimplify[%-poly]

DistinguishingNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"DistinguishingNumber"],{n,5}]

DomaticNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"DomaticNumber"],{n,5}]

DominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"DominatingSetCount"],{n,5}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

DominationNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"DominationNumber"],{n,5}]

seq=Table[DominationNumber[HexagonalGridGraph[{n,n,n}]],{n,10}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]//FullSimplify

DominationPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"DominationPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//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]

FullSimplify[poly2-poly]

EdgeChromaticNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"EdgeChromaticNumber"],{n,5}]

EdgeConnectivity

Table[GraphData[{"HexagonalGrid",{n,n,n}},"EdgeConnectivity"],{n,5}]

EdgeCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"EdgeCount"],{n,5}]

FindSequenceFunction[seq,n]//Factor

EdgeCoverCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"EdgeCoverCount"],{n,5}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

EdgeCoverNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"EdgeCoverNumber"],{n,5}]

FindSequenceFunction[seq,n]

EdgeCoverPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"EdgeCoverPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

coef=Factor/@FindLinearRecurrence[poly]

EulerianCycleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"EulerianCycleCount"],{n,5}]

FaceCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"FaceCount"],{n,5}]

FindSequenceFunction[seq,n]//Factor

FlowPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"FlowPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

coef=Factor/@FindLinearRecurrence[poly]

FractionalChromaticNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"FractionalChromaticNumber"],{n,5}]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"FractionalEdgeChromaticNumber"],{n,5}]

Genus

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Genus"],{n,5}]

Girth

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Girth"],{n,5}]

GlobalClusteringCoefficient

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"GlobalClusteringCoefficient"],{n,5}]

Gonality

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Gonality"],{n,5}]

GracefulLabelingCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"GracefulLabelingCount"],{n,5}]

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"FundamentalGracefulLabelings","Count"],{n,5}]

HamiltonDecompositionCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"HamiltonDecompositionCount"],{n,5}]

Hamiltonian

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Hamiltonian"],{n,5}]

HamiltonianCycleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"HamiltonianCycleCount"],{n,5}]

HamiltonianNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"HamiltonianNumber"],{n,5}]

HamiltonianPathCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"HamiltonianPathCount"],{n,5}]

HamiltonianWalkCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"HamiltonianWalkCount"],{n,5}]

HararyIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"HararyIndex"],{n,5}]

FindLinearRecurrence[seq]//Head

FindSequenceFunction[seq,n]

(seq=Table[HararyIndex[HexagonalGridGraph[{n,n,n}]],{n,15}])//Timing

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

HexagonCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"HexagonCount"],{n,5}]

FindSequenceFunction[seq,n]//Factor

IdiosyncraticPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"IdiosyncraticPolynomial"]/.f_Function:>f[x,y],{n,k0=1,kmax=5}])//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]

IndependenceNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"IndependenceNumber"],{n,5}]

FindSequenceFunction[seq,n]

IndependencePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"IndependencePolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

Factor/@FindLinearRecurrence[DeleteMissing@poly]//Head

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]

IndependenceRatio

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"IndependenceRatio"],{n,5}]

IndependentEdgeSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"IndependentEdgeSetCount"],{n,5}]

IndependentVertexSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"IndependentVertexSetCount"],{n,5}]

FindSequenceFunction[DeleteMissing@seq,n]

IntersectionNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"IntersectionNumber"],{n,5}]

IrredundancePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"IrredundancePolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

IrredundantSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"IrredundantSetCount"],{n,5}]

IsolatedPointCount

Table[GraphData[{"HexagonalGrid",{n,n,n}},"IsolatedPointCount"],{n,5}]

KirchhoffIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"KirchhoffIndex"],{n,5}]

(seq=Table[KirchhoffIndex[HexagonalGridGraph[{n,n,n}]],{n,7}])//Timing

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

KirchhoffSumIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"KirchhoffSumIndex"],{n,5}]

(seq=Table[KirchhoffSumIndex[HexagonalGridGraph[{n,n,n}]],{n,7}])//Timing

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

KleinBottleCrossingNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"KleinBottleCrossingNumber"],{n,5}]

LaplacianPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"LaplacianPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

LeafCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"LeafCount"],{n,5}]

Likelihood

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Likelihood"],{n,5}]

LongestCycleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"LongestCycleCount"],{n,5}]

LongestPathLength

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"LongestPathLength"],{n,5}]

FindSequenceFunction[seq,n]//Factor

LongestPathCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"LongestPathCount"],{n,5}]

LovaszNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"LovaszNumber"],{n,5}]

MatchingGeneratingPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MatchingGeneratingPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

coef=Factor/@FindLinearRecurrence[poly]

MatchingNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MatchingNumber"],{n,5}]

FindSequenceFunction[seq,n]

MatchingPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MatchingPolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

MaximalCliqueCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalCliqueCount"],{n,5}]

FindSequenceFunction[seq,n]//Factor

MaximalCliquePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalCliquePolynomial"],{n,k0=1,5}]/.f_Function:>f[x])

gf=x FindGeneratingFunction[poly,x]

SeriesCoefficient[gf,{x,0,n}]//Factor

MaximalIndependencePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalIndependencePolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MaximalIndependentEdgeSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalIndependentEdgeSetCount"],{n,5}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

MaximalIndependentVertexSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalIndependentVertexSetCount"],{n,5}]

MaximalIrredundancePolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalIrredundancePolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MaximalIrredundantSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalIrredundantSetCount"],{n,5}]

MaximalMatchingGeneratingPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximalMatchingGeneratingPolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MaximumCliqueCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximumCliqueCount"],{n,5}]

FindSequenceFunction[seq,n]//Factor

MaximumIndependentEdgeSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximumIndependentEdgeSetCount"],{n,5}]

FindSequenceFunction[seq,n]

MaximumIndependentVertexSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximumIndependentVertexSetCount"],{n,5}]

MaximumIrredundantSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximumIrredundantSetCount"],{n,5}]

MaximumLeafNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximumLeafNumber"],{n,5}]

MaximumVertexDegree

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MaximumVertexDegree"],{n,5}]

MeanClusteringCoefficient

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MeanClusteringCoefficient"],{n,5}]

MeanDistance

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MeanDistance"],{n,5}]

(seq=Table[MeanDistance[HexagonalGridGraph[{n,n,n}]],{n,15}])//Timing

FindSequenceFunction[seq,n]//Factor

Median

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Median"],{n,5}]

MinimalConnectedDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalConnectedDominatingSetCount"],{n,5}]

MinimalConnectedDominationPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalConnectedDominationPolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MinimalDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalDominatingSetCount"],{n,5}]

MinimalDominationPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalDominationPolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MinimalDominatingSetSignature

(seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalDominatingSetSignature"],{n,5}])//Column

MinimalEdgeCoverCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalEdgeCoverCount"],{n,5}]

MinimalEdgeCoverPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalEdgeCoverPolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MinimalTotalDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalTotalDominatingSetCount"],{n,5}]

MinimalTotalDominationPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalTotalDominationPolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MinimalVertexCoverCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalVertexCoverCount"],{n,5}]

MinimalVertexCoverPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalVertexCoverPolynomial"],{n,k0=1,5}]/.f_Function:>f[x])//Column

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumConnectedDominatingSetCount"],{n,5}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

MinimumCoveringsByMaximalCliquesCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumCoveringsByMaximalCliquesCount"],{n,5}]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumDistinguishingLabelingCount"],{n,5}]

FindSequenceFunction[seq,n]

MinimumDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumDominatingSetCount"],{n,5}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumEdgeCoverCount"],{n,5}]

MinimumTotalDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumTotalDominatingSetCount"],{n,5}]

MinimumTotalDominatingSetCount

(poly=Factor[Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumTotalDominatingSetCount"],{n,k0=1,kmax=5}]/.f_Function:>f[x]])//Column

MinimalVertexCoverCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimalVertexCoverCount"],{n,5}]

MinimumVertexCoverCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumVertexCoverCount"],{n,5}]

MinimumVertexDegree

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MinimumVertexDegree"],{n,5}]

MolecularTopologicalIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"MolecularTopologicalIndex"],{n,5}]

(seq=Table[MolecularTopologicalIndex[HexagonalGridGraph[{n,n,n}]],{n,7}])//Timing

FindSequenceFunction[seq,n]//Factor

Nonhamiltonian

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Nonhamiltonian"],{n,5}]

OddChordlessCycleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"OddChordlessCycleCount"],{n,5}]

OddChordlessCyclePolynomial

(poly=Factor[Table[GraphData[{"HexagonalGrid",{n,n,n}},"OddChordlessCyclePolynomial"],{n,k0=1,kmax=5}]/.f_Function:>f[x]])

PathCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"PathCount"],{n,5}]

PathPolynomial

(poly=Factor[Table[GraphData[{"HexagonalGrid",{n,n,n}},"PathPolynomial"],{n,k0=1,kmax=5}]/.f_Function:>f[x]])//Column

CoefficientList[Take[poly,7],x]

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

Pathwidth

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Pathwidth"],{n,5}]

PentagonCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"PentagonCount"],{n,5}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ProjectivePlaneCrossingNumber"],{n,5}]

Radius

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Radius"],{n,5}]

FindSequenceFunction[seq,n]

Rank

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Rank"],{n,5}]

FindSequenceFunction[seq,n]//Factor

RankPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"RankPolynomial"]/.f_Function:>f[x,y],{n,k0=1,kmax=5}])//Column

coef=Factor/@FindLinearRecurrence[poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"RectilinearCrossingNumber"],{n,5}]

ReliabilityPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"ReliabilityPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

coef=Factor/@FindLinearRecurrence[poly]

ResistanceMatrix

MatrixForm/@Table[GraphData[{"HexagonalGrid",{n,n,n}},"ResistanceMatrix"],{n,5}]

ShannonCapacity

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ShannonCapacity"],{n,5}]

FindSequenceFunction[seq,n]

SigmaPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"SigmaPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

coef=Factor/@FindLinearRecurrence[poly]

coef=Factor/@FindPolynomialRecurrence[poly,6]

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]

Table[n x(3x+2)-2x^2+1,{n,10}]

FullSimplify[%-poly]

Skewness

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Skewness"],{n,5}]

SpanningTreeCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"SpanningTreeCount"],{n,5}]

FindSequenceFunction[seq,n]

SpectralRadius

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"SpectralRadius"],{n,5}]

SquareCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"SquareCount"],{n,5}]

StabilityIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"StabilityIndex"],{n,5}]

(seq=Table[StabilityIndex[HexagonalGridGraph[{n,n,n}]],{n,5}])//Timing

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

SymmetricallyDistinctVertexPairCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"SymmetricallyDistinctVertexPairCount"],{n,5}]

(seq=Table[Length[SymmetricallyDistinctVertexPairs[HexagonalGridGraph[{n,n,n}]]],{n,8}])//Timing

FindSequenceFunction[seq,n]//Factor

Thickness

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Thickness"],{n,5}]

TopologicalIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"TopologicalIndex"],{n,5}]

(seq=Table[TopologicalIndex[HexagonalGridGraph[{n,n,n}]],{n,10}])//Timing

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

ToroidalCrossingNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"ToroidalCrossingNumber"],{n,5}]

TotalDominatingSetCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"TotalDominatingSetCount"],{n,5}]

TotalDominationNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"TotalDominationNumber"],{n,5}]

TotalDominationPolynomial

(poly=Factor[Table[GraphData[{"HexagonalGrid",{n,n,n}},"TotalDominationPolynomial"],{n,k0=1,kmax=5}]/.f_Function:>f[x]])//Column

Traceable

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Traceable"],{n,5}]

TreeDepth

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"TreeDepth"],{n,5}]

Treewidth

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Treewidth"],{n,5}]

Triameter

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"Triameter"],{n,5}]

FindSequenceFunction[seq,n]//Factor

TriangleCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"TriangleCount"],{n,5}]

TuttePolynomial

Table[GraphData[{"HexagonalGrid",{n,n,n}},"TuttePolynomial"]/.f_Function:>f[x,y],{n,5}]//Column

Untraceable

Table[GraphData[{"HexagonalGrid",{n,n,n}},"Untraceable"],{n,5}]

VertexConnectivity

Table[GraphData[{"HexagonalGrid",{n,n,n}},"VertexConnectivity"],{n,5}]

VertexCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"VertexCount"],{n,5}]

FindSequenceFunction[seq,n]

VertexCoverCount

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"VertexCoverCount"],{n,5}]

FindSequenceFunction[DeleteMissing@seq,n]

FindGeneratingFunction[DeleteMissing@seq,x]

VertexCoverNumber

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"VertexCoverNumber"],{n,5}]

FindSequenceFunction[seq,n]

VertexCoverPolynomial

(poly=Factor@Table[GraphData[{"HexagonalGrid",{n,n,n}},"VertexCoverPolynomial"]/.f_Function:>f[x],{n,k0=1,kmax=5}])//Column

Factor/@FindLinearRecurrence[DeleteMissing@poly]//Head

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]

VertexDegrees

Tally/@Table[GraphData[{"HexagonalGrid",{n,n,n}},"VertexDegrees"],{n,5}]//Column

WienerIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"WienerIndex"],{n,5}]

(seq=Table[WienerIndex[HexagonalGridGraph[{n,n,n}]],{n,10}])//Timing

FindSequenceFunction[seq,n]//Factor

WienerSumIndex

seq=Table[GraphData[{"HexagonalGrid",{n,n,n}},"WienerSumIndex"],{n,5}]

(seq=Table[WienerSumIndex[HexagonalGridGraph[{n,n,n}]],{n,9}])//Timing

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

GraphData

GraphDataString

file=OpenAppend["~/hexagon-grid.m"]

WriteString[file,GraphDataString[
HexagonalGridGraph[#/.{1,1,x_}:>{x,1,1}],
"StandardName"->{"HexagonalGrid",#},
"AlternateStandardNames"->If[MatchQ[#,{1,1,_}],{{"PolyhexBar",Last[#]}},{}],
"Name"->"("<>StringTake[StringReplace[ToString[#]," "->""],{2,-2}]<>")\[Hyphen]hexagonal grid graph",
"AlternateNames"->If[MatchQ[#,{1,1,_}],{ToString[Last[#]]<>"\[Hyphen]polyhex bar"},{}],
"Classes"->{"Fusene","HexagonalGrid","Polyhex"},
"NotationRules"->{"Fusene"->Missing["NotAvailable"]},
"Skip"->{"Arboricity","ConnectedInducedSubgraphs","ConnectedInducedSubgraphPolynomial","DistanceRegular","EdgeCovers","EigenvectorCentralities","GracefulLabeling","HamiltonianWalks","IrredundantSets","MinimumCoveringsByMaximalCliques"},
TimeConstraint->10,
MemoryConstraint->10*^9
]]&/@{{2,4,4},{2,4,5},{2,5,5},{3,3,3},{3,3,4},{3,3,5},{3,4,4},{3,4,5},{3,5,5},{4,4,4},{4,4,5},{4,5,5},{5,5,5}};

Close[file]