Cycle Graph

Author

Eric W. Weisstein
March 1, 2024

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

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

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

Figure

GraphData

GraphicsRow[Table[GraphData[{"Cycle",n}],{n,3,7}],Dividers->All]//StyleGraphs[#,VertexSize->{"Scaled",.08}]&

Built-in

GraphicsRow[Table[CycleGraph[n,VertexSize->If[n==1,.02,{"Scaled",.08}],System`VertexStyle->Red,System`EdgeStyle->Gray],{n,5}],Dividers->All]

Special cases

ToEntity/@Table[CycleGraph[n],{n,10}]

Embeddings

<<MathWorld`Graphs`

{"Cycle", 3} == "TriangleGraph"

Names

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

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

{"Cycle", 4} == "SquareGraph"

Names

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

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

{"Cycle", 5}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Cycle",5},"Polyhedron"]

GeneralizedPetersen

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

IGraph

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

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",5}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Cycle", 6}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Cycle",6},"Polyhedron"]

PolyhedronGraph[GraphData[{"Cycle",6},"Polyhedron"]]

HoneycombToroidal construction

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

HoneycombToroidalGraph[1,6,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=6},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",6}}]]//Timing

gs=GeneralizedHoneycombGraph[6,#]&/@{1,3}

RecognizeGraph/@gs

GeneralizedPetersen

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

IGraph

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

Bilateral

GraphData[{"Cycle",6},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",6}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Circulant construction

GraphData[{"Cycle",6},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cycle",6}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cycle",6},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

gs={,};

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

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

gs=LineGraph/@%

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cycle",6},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",6}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",6}],All])[[All,2]]]//Timing

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Cycle", 10}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Cycle",10},"Polyhedron"]

HoneycombToroidal construction

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

HoneycombToroidalGraph[1,10,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=10},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",10}}]]//Timing

GeneralizedPetersen

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

IGraph

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

Bilateral

GraphData[{"Cycle",10},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",10}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Complement graph

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

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

GraphComplement/@%

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cycle",10},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",10}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",10}],All])[[All,2]]]//Timing

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Cycle", 12}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Cycle",12},"Polyhedron"]

HoneycombToroidal construction

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

HoneycombToroidalGraph[1,12,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=24},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",12}}]]//Timing

g=GeneralizedHoneycombGraph[,]

RecognizeGraph@g

GeneralizedPetersen

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

IGraph

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

Bilateral

GraphData[{"Cycle",12},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",12}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

GraphData[{"Cycle",12},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cycle",12},"Rigid"]

GraphData[{"Cycle",12},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cycle",12},"Flexible"]

GraphData[{"Cycle",12},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cycle",12},"LCF"]

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

GraphData[{"Cycle",12},"LCFSignature"]

GraphData[{"Cycle",12},"LCFNotations"]

GraphData[{"Cycle",12},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"Cycle",12},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",12}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",12}],All])[[All,2]]]//Timing

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cycle",12},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cycle",12}],Debug->True]//Timing

GraphData[{"Cycle",12},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cycle",12},"VertexList"],GraphData[{"Cycle",12},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Cycle",12},"Matchstick"]

GraphData[{"Cycle",12},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cycle",12},"Edges"]]

3D All

GraphData[{"Cycle",12},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cycle",12},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cycle",12},"Polyhedral"]

GraphData[{"Cycle",12},"Graph",{"3D","Polyhedron"}]

{"Cycle", 14}

Names

GraphData[{"Cycle",14},"StandardName"]

GraphData[{"Cycle",14},"StandardNames"]

Primary

GraphData[{"Cycle",14}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cycle",14},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Cycle",14},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Cycle",14},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Cycle",14},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cycle",14},"Graph","Degenerate"]

Configuration

GraphData[{"Cycle",14},"Configuration"]

GraphData[{"Cycle",14},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Cycle",14},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Cycle",14},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"Cycle",14},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,14,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=14},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",14}}]]//Timing

g=GeneralizedHoneycombGraph[14,7]

RecognizeGraph@g

GeneralizedPetersen

GraphData[{"Cycle",14},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cycle",14},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cycle",14},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Cycle",14},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Cycle",14},"Planar"]

GraphData[{"Cycle",14},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Cycle",14},{"RCN","CN"}]

GraphData[{"Cycle",14},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",14}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Cycle",14},"Circulant"]

GraphData[{"Cycle",14},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Cycle",14},"ComplementGraph","Name"]

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

GraphComplement/@%

gs={,,,};

Line graph

GraphData[{"Cycle",14},"Line"]

LineGraphQ[GraphData[{"Cycle",14}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Cycle",14}&]

RootGraph[GraphData[{"Cycle",14}]]

Halin

GraphData[{"Cycle",14},"Halin"]

GraphData[{"Cycle",14},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cycle",14},"Rigid"]

GraphData[{"Cycle",14},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cycle",14},"Flexible"]

GraphData[{"Cycle",14},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cycle",14},"LCF"]

GraphData[{"Cycle",14},"HamiltonianCycleCount"]

GraphData[{"Cycle",14},"LCFSignature"]

GraphData[{"Cycle",14},"LCFNotations"]

GraphData[{"Cycle",14},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"Cycle",14},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",14}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",14}],All])[[All,2]]]//Timing

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cycle",14},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cycle",14}],Debug->True]//Timing

GraphData[{"Cycle",14},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cycle",14},"VertexList"],GraphData[{"Cycle",14},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Cycle",14},"Matchstick"]

GraphData[{"Cycle",14},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cycle",14},"Edges"]]

3D All

GraphData[{"Cycle",14},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cycle",14},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cycle",14},"Polyhedral"]

GraphData[{"Cycle",14},"Graph",{"3D","Polyhedron"}]

{"Cycle", 16}

Names

GraphData[{"Cycle",16},"StandardName"]

GraphData[{"Cycle",16},"StandardNames"]

Primary

GraphData[{"Cycle",16}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cycle",16},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Cycle",16},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Cycle",16},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Cycle",16},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cycle",16},"Graph","Degenerate"]

Configuration

GraphData[{"Cycle",16},"Configuration"]

GraphData[{"Cycle",16},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Cycle",16},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Cycle",16},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"Cycle",16},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,16,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=16},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",16}}]]//Timing

g=GeneralizedHoneycombGraph[1,]

RecognizeGraph@g

GeneralizedPetersen

GraphData[{"Cycle",16},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cycle",16},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cycle",16},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Cycle",16},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Cycle",16},"Planar"]

GraphData[{"Cycle",16},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Cycle",16},{"RCN","CN"}]

GraphData[{"Cycle",16},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",16}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Cycle",16},"Circulant"]

GraphData[{"Cycle",16},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Cycle",16},"ComplementGraph","Name"]

Line graph

GraphData[{"Cycle",16},"Line"]

LineGraphQ[GraphData[{"Cycle",16}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Cycle",16}&]

RootGraph[GraphData[{"Cycle",16}]]

Halin

GraphData[{"Cycle",16},"Halin"]

GraphData[{"Cycle",16},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cycle",16},"Rigid"]

GraphData[{"Cycle",16},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cycle",16},"Flexible"]

GraphData[{"Cycle",16},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cycle",16},"LCF"]

GraphData[{"Cycle",16},"HamiltonianCycleCount"]

GraphData[{"Cycle",16},"LCFSignature"]

GraphData[{"Cycle",16},"LCFNotations"]

GraphData[{"Cycle",16},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"Cycle",16},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",16}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",16}],All])[[All,2]]]//Timing

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cycle",16},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cycle",16}],Debug->True]//Timing

GraphData[{"Cycle",16},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cycle",16},"VertexList"],GraphData[{"Cycle",16},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Cycle",16},"Matchstick"]

GraphData[{"Cycle",16},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cycle",16},"Edges"]]

3D All

GraphData[{"Cycle",16},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cycle",16},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cycle",16},"Polyhedral"]

GraphData[{"Cycle",16},"Graph",{"3D","Polyhedron"}]

{"Cycle", 18}

Names

GraphData[{"Cycle",18},"StandardName"]

GraphData[{"Cycle",18},"StandardNames"]

Primary

GraphData[{"Cycle",18}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cycle",18},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Cycle",18},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Cycle",18},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Cycle",18},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cycle",18},"Graph","Degenerate"]

Configuration

GraphData[{"Cycle",18},"Configuration"]

GraphData[{"Cycle",18},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Cycle",18},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Cycle",18},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"Cycle",18},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,18,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=18},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",18}}]]//Timing

g=GeneralizedHoneycombGraph[18,9]

RecognizeGraph@g

GeneralizedPetersen

GraphData[{"Cycle",18},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cycle",18},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cycle",18},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Cycle",18},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Cycle",18},"Planar"]

GraphData[{"Cycle",18},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Cycle",18},{"RCN","CN"}]

GraphData[{"Cycle",18},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",18}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Cycle",18},"Circulant"]

GraphData[{"Cycle",18},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Cycle",18},"ComplementGraph","Name"]

Line graph

GraphData[{"Cycle",18},"Line"]

LineGraphQ[GraphData[{"Cycle",18}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Cycle",18}&]

RootGraph[GraphData[{"Cycle",18}]]

Halin

GraphData[{"Cycle",18},"Halin"]

GraphData[{"Cycle",18},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cycle",18},"Rigid"]

GraphData[{"Cycle",18},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cycle",18},"Flexible"]

GraphData[{"Cycle",18},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cycle",18},"LCF"]

GraphData[{"Cycle",18},"HamiltonianCycleCount"]

GraphData[{"Cycle",18},"LCFSignature"]

GraphData[{"Cycle",18},"LCFNotations"]

GraphData[{"Cycle",18},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"Cycle",18},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",18}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",18}],All])[[All,2]]]//Timing

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cycle",18},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cycle",18}],Debug->True]//Timing

GraphData[{"Cycle",18},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cycle",18},"VertexList"],GraphData[{"Cycle",18},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Cycle",18},"Matchstick"]

GraphData[{"Cycle",18},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cycle",18},"Edges"]]

3D All

GraphData[{"Cycle",18},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cycle",18},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cycle",18},"Polyhedral"]

GraphData[{"Cycle",18},"Graph",{"3D","Polyhedron"}]

{"Cycle", 22}

Names

GraphData[{"Cycle",22},"StandardName"]

GraphData[{"Cycle",22},"StandardNames"]

Primary

GraphData[{"Cycle",22}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cycle",22},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Cycle",22},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Cycle",22},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Cycle",22},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cycle",22},"Graph","Degenerate"]

Configuration

GraphData[{"Cycle",22},"Configuration"]

GraphData[{"Cycle",22},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Cycle",22},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Cycle",22},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"Cycle",22},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,22,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=22},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",22}}]]//Timing

g=GeneralizedHoneycombGraph[22,11]

RecognizeGraph@g

GeneralizedPetersen

GraphData[{"Cycle",22},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cycle",22},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cycle",22},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Cycle",22},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Cycle",22},"Planar"]

GraphData[{"Cycle",22},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Cycle",22},{"RCN","CN"}]

GraphData[{"Cycle",22},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",22}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Cycle",22},"Circulant"]

GraphData[{"Cycle",22},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Cycle",22},"ComplementGraph","Name"]

Line graph

GraphData[{"Cycle",22},"Line"]

LineGraphQ[GraphData[{"Cycle",22}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Cycle",22}&]

RootGraph[GraphData[{"Cycle",22}]]

Halin

GraphData[{"Cycle",22},"Halin"]

GraphData[{"Cycle",22},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cycle",22},"Rigid"]

GraphData[{"Cycle",22},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cycle",22},"Flexible"]

GraphData[{"Cycle",22},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cycle",22},"LCF"]

GraphData[{"Cycle",22},"HamiltonianCycleCount"]

GraphData[{"Cycle",22},"LCFSignature"]

GraphData[{"Cycle",22},"LCFNotations"]

GraphData[{"Cycle",22},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"Cycle",22}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Cycle",22}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"Cycle",22},{0,Missing["NotAvailable",LCFNotation/@gs]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"Cycle",22},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",22}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",22}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"Cycle",22},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cycle",22},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cycle",22}],Debug->True]//Timing

GraphData[{"Cycle",22},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cycle",22},"VertexList"],GraphData[{"Cycle",22},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Cycle",22},"Matchstick"]

GraphData[{"Cycle",22},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cycle",22},"Edges"]]

3D All

GraphData[{"Cycle",22},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cycle",22},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cycle",22},"Polyhedral"]

GraphData[{"Cycle",22},"Graph",{"3D","Polyhedron"}]

{"Cycle",30}

Names

GraphData[{"Cycle",30},"StandardName"]

GraphData[{"Cycle",30},"StandardNames"]

Primary

GraphData[{"Cycle",30}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cycle",30},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Cycle",30},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Cycle",30},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Cycle",30},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cycle",30},"Graph","Degenerate"]

Configuration

GraphData[{"Cycle",30},"Configuration"]

GraphData[{"Cycle",30},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Cycle",30},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Cycle",30},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"Cycle",30},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,30,1]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=30},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"Cycle",30}}]]//Timing

g=GeneralizedHoneycombGraph[30,15]

RecognizeGraph@g

GeneralizedPetersen

GraphData[{"Cycle",30},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cycle",30},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cycle",30},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Cycle",30},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Cycle",30},"Planar"]

GraphData[{"Cycle",30},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Cycle",30},{"RCN","CN"}]

GraphData[{"Cycle",30},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"Cycle",30}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Cycle",30},"Circulant"]

GraphData[{"Cycle",30},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"Cycle",30},"ComplementGraph","Name"]

Line graph

GraphData[{"Cycle",30},"Line"]

LineGraphQ[GraphData[{"Cycle",30}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Cycle",30}&]

RootGraph[GraphData[{"Cycle",30}]]

Halin

GraphData[{"Cycle",30},"Halin"]

GraphData[{"Cycle",30},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cycle",30},"Rigid"]

GraphData[{"Cycle",30},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cycle",30},"Flexible"]

GraphData[{"Cycle",30},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cycle",30},"LCF"]

GraphData[{"Cycle",30},"HamiltonianCycleCount"]

GraphData[{"Cycle",30},"LCFSignature"]

GraphData[{"Cycle",30},"LCFNotations"]

GraphData[{"Cycle",30},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"Cycle",30}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Cycle",30}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"Cycle",30},{0,Missing["NotAvailable",LCFNotation/@gs]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"Cycle",30},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cycle",30}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cycle",30}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"Cycle",30},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cycle",30},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cycle",30}],Debug->True]//Timing

GraphData[{"Cycle",30},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cycle",30},"VertexList"],GraphData[{"Cycle",30},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Cycle",30},"Matchstick"]

GraphData[{"Cycle",30},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cycle",30},"Edges"]]

3D All

GraphData[{"Cycle",30},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cycle",30},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cycle",30},"Polyhedral"]

GraphData[{"Cycle",30},"Graph",{"3D","Polyhedron"}]

ModuloMultiplicationGraph

GroupCycles[5]

ShowLabeledGraph[ModuloMultiplicationGraph[5,Type->Directed],
VertexStyle->Disk[.035],VertexColor->Red,PlotRange->All]

Properties

Acyclic

Table[GraphData[{"Cycle",n},"Acyclic"],{n,3,20}]

AdjacencyMatrixCount

seq=Table[GraphData[{"Cycle",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Arboricity

Table[GraphData[{"Cycle",n},"Arboricity"],{n,3,20}]

ArcTransitive

Table[GraphData[{"Cycle",n},"ArcTransitive"],{n,3,20}]

ArcTransitivity

Table[GraphData[{"Cycle",n},"ArcTransitivity"],{n,3,20}]

AutomorphismCount

seq=Table[GraphData[{"Cycle",n},"AutomorphismCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

BalabanIndex

seq=Table[GraphData[{"Cycle",n},"BalabanIndex"],{n,3,20}]//FullSimplify

FindSequenceFunction[seq,n-2]//FullSimplify

Table[(((((-1))^n) (-1+(((-1))^n) (-1+2 (n^2))))/(-1+(n^2))),{n,3,20}]

Table[Piecewise[{{2,Mod[n,2]==0},{2 n^2/(n^2-1),Mod[n,2]==1}}],{n,3,20}]

gf=(x^3)FindGeneratingFunction[seq,x]//FullSimplify

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

FullSimplify[%,n>2]

Bandwidth

Table[GraphData[{"Cycle",n},"Bandwidth"],{n,3,20}]

BridgeCount

seq=Table[GraphData[{"Cycle",n},"BridgeCount"],{n,3,20}]

BurningNumber

seq=Table[GraphData[{"Cycle",n},"BurningNumber"],{n,3,20}]

https://arxiv.org/pdf/1507.06524.pdf, Corollary 11

Table[Ceiling[Sqrt[n]],{n,3,20}]

CharacteristicPolynomial

A123343 and  A198637

(poly=Factor@Table[GraphData[{"Cycle",n},"CharacteristicPolynomial"][x],{n,k0=3,20}])//Column

CoefficientList[#,x]&/@(Take[poly,7]//Expand)//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[2*(ChebyshevT[n,x/2]-1),{n,3,10}]//Factor

poly2=Table[2(ChebyshevT[n,x/2]-1),{n,3,20}]//Factor

Abs[FullSimplify[poly2/poly]]

A123343

Table[CoefficientList[CharacteristicPolynomial[AdjacencyMatrix[CycleGraph[n]],x],x],{n,3,7}]//Column

Flatten[{{1},{1,-1},{-1,0,1},Table[CoefficientList[CharacteristicPolynomial[AdjacencyMatrix[CycleGraph[n]],x],x],{n,3,10}]}]

Flatten[{{1},{1,-1},{-1,0,1},Table[CoefficientList[(-1)^n 2(ChebyshevT[n,x/2]-1),x],{n,3,10}]}]

%==%%

A198637

Flatten[{{1},{0,1},Table[(-1)^n CoefficientList[CharacteristicPolynomial[AdjacencyMatrix[CycleGraph[n]],x],x],{n,2,10}]}]

Flatten[{{1},{0,1},Table[CoefficientList[2(ChebyshevT[n,x/2]-1),x],{n,2,10}]}]

%==%%

poly2=Table[2 (ChebyshevT[n,x/2]-1),{n,3,20}]

Abs[FullSimplify[poly/poly2]]

ChordCount

seq=Table[GraphData[{"Cycle",n},"ChordCount"],{n,3,20}]

ChordlessCycleCount

seq=Table[GraphData[{"Cycle",n},"ChordlessCycleCount"],{n,3,20}]

ChromaticInvariant

seq=Table[GraphData[{"Cycle",n},"ChromaticInvariant"],{n,3,20}]

ChromaticNumber

seq=Table[GraphData[{"Cycle",n},"ChromaticNumber"],{n,3,20}]

ChromaticPolynomial

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

FullSimplify[poly2/poly]

Circumference

seq=Table[GraphData[{"Cycle",n},"Circumference"],{n,3,20}]

FindSequenceFunction[seq,n-2]

Classes

Intersection@@(GraphData[#,"Classes"]&/@GraphData["Cycle"])

CliqueCount

seq=Table[GraphData[{"Cycle",n},"CliqueCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

gf=(x^3)FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>2]

CliqueCoveringNumber

seq=Table[GraphData[{"Cycle",n},"CliqueCoveringNumber"],{n,3,20}]

FindSequenceFunction[Rest@seq,n-3]//FullSimplify

gf=(x^3) FindGeneratingFunction[seq,x]

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

Table[Piecewise[{{1,n==3}},Ceiling[n/2]],{n,3,20}]

%==seq

CliqueNumber

seq=Table[GraphData[{"Cycle",n},"CliqueNumber"],{n,3,20}]

CliquePolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"CliquePolynomial"][x],{n,k0=3,20}])//Column

coef=Factor/@FindLinearRecurrence[poly]

poly2=Table[(Piecewise[{{(1+#)^3,n==3}},1+n #+n #^2]&)@x,{n,3,20}]

FullSimplify[poly2-poly]

ComplementGraphName

t1=Table[GraphData[{"Cycle",n},"ComplementGraph","Name"],{n,3,20}]

t2=Table[{"Circulant",{n,Piecewise[{{DeleteCases[Range[n/2],n/2-1],Mod[n,4]==0},{DeleteCases[Range[n/2],n/2-2],Mod[n,4]==2},{Range[(n-3)/2],Mod[n,2]==1}}]}},{n,3,20}]

DeleteCases[Transpose[{t1,t2}],{x_,x_}]

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"Cycle",n},"ComplementOddChordlessCycleCount"],{n,3,20}]

ConnectedDominatingSetCount

seq=Table[GraphData[{"Cycle",n},"ConnectedDominatingSetCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Simplify

ConnectedDominationNumber

seq=Table[GraphData[{"Cycle",n},"ConnectedDominationNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

ConnectedDominationPolynomial

(poly=DeleteCases[Factor@Table[GraphData[{"Cycle",n},"ConnectedDominationPolynomial"][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[(x^(n-2))((x^2)+n x+n),{n,3,20}]

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

A002061

seq=Table[GraphData[{"Cycle",n},"ConnectedInducedSubgraphCount"],{n,3,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n-2]//Factor

ConnectedInducedSubgraphPolynomial

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

FullSimplify[poly2-poly]

CrossingNumber

seq=Table[GraphData[{"Cycle",n},"CrossingNumber"],{n,3,20}]

CycleCount

seq=Table[GraphData[{"Cycle",n},"CycleCount"],{n,3,20}]

CyclePolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"CyclePolynomial"][x],{n,k0=3,20}])

poly2=Table[x^n,{n,3,20}]

FullSimplify[poly2-poly]

Cyclic

Table[GraphData[{"Cycle",n},"Cyclic"],{n,3,20}]

CyclomaticNumber

seq=Table[GraphData[{"Cycle",n},"CyclomaticNumber"],{n,3,20}]

DetourIndex

seq=Table[GraphData[{"Cycle",n},"DetourIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

gf=(x^3)FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>2]

Table[(1/16) n (1+(((-1))^(1+n))-8 n+6 (n^2)),{n,3,20}]

Table[Piecewise[{{n^2(3 n-4)/8,Mod[n,2]==0},{(n-1)n(3 n-1)/8,Mod[n,2]==1}}],{n,3,20}]

DetourMatrix

MatrixForm/@Table[GraphData[{"Cycle",n},"DetourMatrix"],{n,3,7}]

MatrixForm/@Table[SparseArray[{{i_,i_}->0,{i_,j_}:>If[Abs[i-j]<n/2,n-Abs[i-j],Abs[i-j]]},n],{n,7}]

DetourPolynomial

Take[poly=Factor@Table[GraphData[{"Cycle",n},"DetourPolynomial"][x],{n,k0=3,20}],11]//Column

coef=Factor/@FindLinearRecurrence[poly]

CoefficientList[#,x]&/@Take[poly,3]

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

FullSimplify[poly2-poly]

Diameter

seq=Table[GraphData[{"Cycle",n},"Diameter"],{n,3,20}]

Table[Floor[n/2],{n,3,20}]

DistanceMatrix

MatrixForm/@(seq=Table[GraphData[{"Cycle",n},"DistanceMatrix"],{n,3,7}])

MatrixForm/@(seq2=Table[SparseArray[{{i_,i_}->0,{i_,j_}:>If[Abs[i-j]<n/2,Abs[i-j],n-Abs[i-j]]},n],{n,3,7}])

seq==seq2

DistancePolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"DistancePolynomial"][x],{n,k0=3,20}])//Factor//Column

coef=Factor/@FindLinearRecurrence[poly]

CoefficientList[Take[poly,5],x]

Table[((GraphData[{"Cycle",n},"DistancePolynomial"][x])/((x-n^2/4) (x^((n-2)/2)))),{n,k0=6,20,4}]

CoefficientList[%,x]

(-I)^n Fibonacci[n+1,-I x]==ChebyshevU[n,-(x/2)]/.{n->n/2,x->-2I/Sqrt[x]}

FullSimplify[(((-(((-1))^(3/4))))^n) Fibonacci[1+(n/2),-(2/(Sqrt[x]))],n∈Integers]

Table[(((-1))^(7 n/4)) Fibonacci[1+(n/2),-(2/(Sqrt[x]))],{n,4,8,2}]//Simplify

Table[(x^(n-1))(x-n^2/4) (ChebyshevT[n/2,I/(Sqrt[x])]^2),{n,4,8,2}]//FullSimplify//Factor

Table[(x^(n-1))(x-n^2/4) (((((-1))^(7 n/4)) Fibonacci[1+(n/2),-(2/(Sqrt[x]))])^2),{n,4,8,2}]//FullSimplify//Factor

(poly2=Factor@Table[Piecewise[{
{(1+x)(x^(n-1))(x-n^2/4) (ChebyshevT[n/2,I/(Sqrt[x])]^2)//FullSimplify,Mod[n,4]==2},
{(x^(n-1))(x-n^2/4) (ChebyshevT[n/2,I/(Sqrt[x])]^2)//FullSimplify,Mod[n,2]==0},
{(x^(n-1)) (x-((n^2)-1)/4)((Fibonacci[n,1/Sqrt[x]])^2),Mod[n,2]==1}
}],{n,3,20}])//Column

FullSimplify[poly2/poly]

DistinguishingNumber

seq=Table[GraphData[{"Cycle",n},"DistinguishingNumber"],{n,3,20}]

DominatingSetCount

A001644

seq=Table[GraphData[{"Cycle",n},"DominatingSetCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

Table[Root[-1-#1-3 ((#1)^2)+((#1)^3)&,1] ((Root[-1-#1-((#1)^2)+((#1)^3)&,1])^(-2+n))+Root[-1-#1-3 ((#1)^2)+((#1)^3)&,3] ((Root[-1-#1-((#1)^2)+((#1)^3)&,2])^(-2+n))+Root[-1-#1-3 ((#1)^2)+((#1)^3)&,2] ((Root[-1-#1-((#1)^2)+((#1)^3)&,3])^(-2+n)),{n,2}]//FullSimplify

FindSequenceFunction[{1,3,7,11,21,39,71,131,241,443,815,1499,2757,5071,9327,17155,31553,58035,106743,196331},n]

Table[RootSum[-1-#-((#)^2)+((#)^3)&,#^n&],{n,3,20}]

Table[RootSum[-1-#-((#)^2)+((#)^3)&,#^n&],{n,0,20}]

DominationNumber

seq=Table[GraphData[{"Cycle",n},"DominationNumber"],{n,3,20}]

Table[Floor[(n+2)/3],{n,3,20}]

DominationPolynomial

A212634 (dropping initial 0 in each row)

(poly=Factor@Table[GraphData[{"Cycle",n},"DominationPolynomial"][x],{n,k0=3,20}])//Column

CoefficientList[Take[poly,5],x]

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}]

CoefficientList[LinearRecurrence[{x,x,x},{1,2+x, 3+3 x+(x^2)},10],x]

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]]

SeriesCoefficient[gf,{z,0,n}]

poly2=LinearRecurrence[{x,x,x},x{1,2+x, 3+3 x+(x^2)},{3,20}]

FullSimplify[poly2-poly]

EdgeChromaticNumber

seq=Table[GraphData[{"Cycle",n},"EdgeChromaticNumber"],{n,3,20}]

EdgeConnectivity

Table[GraphData[{"Cycle",n},"EdgeConnectivity"],{n,3,20}]

EdgeCount

seq=Table[GraphData[{"Cycle",n},"EdgeCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

EdgeCoverCount

seq=Table[GraphData[{"Cycle",n},"EdgeCoverCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[(1/2) (5 Fibonacci[-2+n]+3 LucasL[-2+n]),{n,3,20}]

gf=(x^3)FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>2]

Table[LucasL[n],{n,3,20}]

EdgeCoverNumber

seq=Table[GraphData[{"Cycle",n},"EdgeCoverNumber"],{n,3,20}]

Table[Ceiling[n/2],{n,3,20}]

EdgeCoverPolynomial

A284966

(poly=Factor@Table[GraphData[{"Cycle",n},"EdgeCoverPolynomial"][x],{n,k0=3,20}])//Column

poly//Expand//Column

CoefficientList[Take[poly,7],x]

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}]

CoefficientList[LinearRecurrence[{x,x},{x,x (2+x)},15],x]

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[(2^(-n)) ((((x-(Sqrt[x]) (Sqrt[4+x])))^n)+(((x+(Sqrt[x]) (Sqrt[4+x])))^n)),{n,3,20}]

FullSimplify[poly2-poly]

(poly2=Table[2 (x^n)(-1/x)^(n/2) ChebyshevT[n,1/(2 Sqrt[-1/x])],{n,3,20}]//Expand)//Column

FullSimplify[poly2-poly]

FunctionExpand[2 x^n (-1/x)^(n/2) ChebyshevT[n,1/(2 Sqrt[-1/x])]]//FullSimplify

2(-1/x)^(n/2)ChebyshevT[n,1/(2 Sqrt[-1/x])]==(x^(-n/2)) LucasL[n,(Sqrt[x])]

2 (x^n)(-1/x)^(n/2) ChebyshevT[n,1/(2 Sqrt[-1/x])]

(poly3=Table[(x^(n/2)) LucasL[n,(Sqrt[x])],{n,3,20}]//Expand)//Column

FullSimplify[poly3-poly]

Table[(x^(n/2)) LucasL[n,(Sqrt[x])],{n,0,4}]//Expand

CoefficientList[Table[(x^(n/2)) LucasL[n,(Sqrt[x])],{n,0,12}],x]

Flatten[%]

EulerianCycleCount

seq=Table[GraphData[{"Cycle",n},"EulerianCycleCount"],{n,3,20}]

FaceCount

seq=Table[GraphData[{"Cycle",n},"FaceCount"],{n,3,20}]

FibonacciCube

Entity["Graph",{"Cycle",n}]["FibonacciCube"]

seq=Table[GraphData[{"Cycle",n},"FibonacciCube"],{n,3,20}]

FlowPolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"FlowPolynomial"][x],{n,k0=3,20}])//Column

FractionalChromaticNumber

seq=Table[GraphData[{"Cycle",n},"FractionalChromaticNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[Piecewise[{{2,Mod[n,2]==0},{((2n)/(n-1)),Mod[n,2]==1}}],{n,3,20}]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"Cycle",n},"FractionalEdgeChromaticNumber"],{n,3,20}]

Girth

seq=Table[GraphData[{"Cycle",n},"Girth"],{n,3,20}]

Gonality

seq=Table[GraphData[{"Cycle",n},"Gonality"],{n,3,20}]

HamiltonConnected

seq=Table[GraphData[{"Cycle",n},"HamiltonConnected"],{n,3,20}]

HamiltonDecompositionCount

seq=Table[GraphData[{"Cycle",n},"HamiltonDecompositionCount"],{n,3,20}]

Hamiltonian

Table[GraphData[{"Cycle",n},"Hamiltonian"],{n,3,20}]

HamiltonianCycleCount

seq=Table[GraphData[{"Cycle",n},"HamiltonianCycleCount"],{n,3,20}]

HamiltonianCycles

Table[GraphData[{"Cycle",n},"HamiltonianCycles"],{n,3,6}]

UndirectedEdge@@@Partition[Range[4],2,1,1]

HamiltonianNumber

seq=Table[GraphData[{"Cycle",n},"HamiltonianNumber"],{n,3,20}]

HamiltonianPathCount

seq=Table[GraphData[{"Cycle",n},"HamiltonianPathCount"],{n,3,20}]

HamiltonianPaths

seq=Table[GraphData[{"Cycle",n},"HamiltonianPaths"],{n,3,5}]

SimplePaths[l_]:=Union[Sort[{#,Reverse[#]}][[1]]&/@l]

SimplePaths/@Table[Partition[Range[n],n,1,1],{n,3,5}]

%==seq

Partition[Range[4],4,1,1]

SimplePaths[%]

HamiltonianWalkCount

seq=Table[GraphData[{"Cycle",n},"HamiltonianWalkCount"],{n,3,20}]

HararyIndex

seq=Table[GraphData[{"Cycle",n},"HararyIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]

gf=(x^3)FindGeneratingFunction[seq,x]

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

HexagonCount

seq=Table[GraphData[{"Cycle",n},"HexagonCount"],{n,3,20}]

HosoyaIndex

Same as IndependentEdgeSetCount

seq=Table[GraphData[{"Cycle",n},"HosoyaIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[LucasL[n],{n,20}]

FindSequenceFunction[Table[LucasL[n],{n,20}],n]

FindSequenceFunction[Table[LucasL[n],{n,3,20}],n-2]//FullSimplify

IdiosyncraticPolynomial

Take[(poly=Factor@Table[GraphData[{"Cycle",n},"IdiosyncraticPolynomial"][x,y],{n,k0=3,20}]),10]//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}]

RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

SeriesCoefficient[gf,{z,0,n}]

poly2=Table[XXX,{n,3,20}]

FullSimplify[poly2-poly]

IndependenceNumber

seq=Table[GraphData[{"Cycle",n},"IndependenceNumber"],{n,3,20}]

Table[Floor[n/2],{n,3,20}]

IndependencePolynomial

A284967

Same as MatchingGeneratingPolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"IndependencePolynomial"][x],{n,k0=3,20}])//Expand//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}]

CoefficientList[LinearRecurrence[{1,x},{1,1+2 x},20],x]

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]

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

(poly2=Table[2(-x)^(n/2)ChebyshevT[n,1/(2 Sqrt[-x])],{n,3,20}]//Expand)//Column

FullSimplify[poly2-poly]

poly3=Table[x^(n/2) LucasL[n,1/Sqrt[x]],{n,3,20}];

FullSimplify[poly-poly3]

SeriesCoefficient[x^(n/2) LucasL[n,1/Sqrt[x]],{x,0,n}]

FunctionExpand[(x^(n/2)) LucasL[n,(1/(Sqrt[x]))]]

FunctionExpand[2(-x)^(n/2)ChebyshevT[n,1/(2 Sqrt[-x])]]

CoefficientList[Table[2 (((-x))^(n/2)) Cos[n ArcSec[2 (Sqrt[-x])]]//FunctionExpand,{n,20}],x]

IndependenceRatio

seq=Table[GraphData[{"Cycle",n},"IndependenceRatio"],{n,3,20}]

Table[Floor[n/2]/n,{n,3,20}]

IndependentEdgeSetCount

A000032

seq=Table[GraphData[{"Cycle",n},"IndependentEdgeSetCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[LucasL[n],{n,20}]

FindSequenceFunction[Table[LucasL[n],{n,20}],n]

FindSequenceFunction[Table[LucasL[n],{n,3,20}],n-2]//FullSimplify

IndependentVertexSetCount

A000032

seq=Table[GraphData[{"Cycle",n},"IndependentVertexSetCount"],{n,3,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n-2]//Factor

seq=LucasL[Range[0,20]]

FindGeneratingFunction[seq,x]

CoefficientList[Series[((-2+x)/(-1+x+(x^2))),{x,0,20}],x]

IntersectionNumber

seq=Table[GraphData[{"Cycle",n},"IntersectionNumber"],{n,3,20}]

IrredundantSetCount

A290493

seq=Table[GraphData[{"Cycle",n},"IrredundantSetCount"],{n,3,20}]

(seq=Table[Length[IrredundantSets[CycleGraph[n]]],{n,3,15}])//Timing

FindLinearRecurrence[seq]

seq=LinearRecurrence[{1,1,0,1,0,-1},{1,3,4,11,16,24},40]

RSolve[{a[n]==a[n-1]+a[n-2]+a[n-4]-a[n-6],a[3]==4,a[4]==1,a[5]==16,a[6]==24,a[7]==43,a[8]==75},a[n],n]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((1+2 x+4 (x^3)-6 (x^5))/(1-x-(x^2)-(x^4)+(x^6))),{x,0,20}],x]

res=Refine[SeriesCoefficient[gf,{x,0,n}],n>1]

terms=List@@res;

N[terms/.n->0]//Chop

terms[[All,1]]

Table[RootSum[1-((#)^2)-((#)^4)-((#)^5)+((#)^6)&,#^n&],{n,20}]

KirchhoffIndex

seq=Table[GraphData[{"Cycle",n},"KirchhoffIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[Binomial[n+1,3]/2,{n,3,20}]

KirchhoffSumIndex

seq=Table[GraphData[{"Cycle",n},"KirchhoffSumIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

LaplacianPolynomial

A284982

(poly=Factor@Table[GraphData[{"Cycle",n},"LaplacianPolynomial"][x],{n,k0=3,20}])//Expand//Column

Take[poly,10]//Expand//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}]

CoefficientList[LinearRecurrence[{3-x,-3+x,1},{-x,(-4+x) x,-(((-3+x))^2) x},10],x]

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[2(ChebyshevT[n,1-x/2]-1),{n,3,20}]//Expand)//Column

FullSimplify[poly2-poly]

FunctionExpand[2(ChebyshevT[n,1-x/2]-1)]//FullSimplify

CoefficientList[FunctionExpand[Table[2 (-1+Cos[n ArcCos[1-(x/2)]]),{n,12}]],x]

(poly3=Table[LucasL[2n,Sqrt[-x]]-2,{n,3,20}]//Expand)//Column

FullSimplify[poly3-poly]

LeafCount

seq=Table[GraphData[{"Cycle",n},"LeafCount"],{n,3,20}]

LongestCycleCount

seq=Table[GraphData[{"Cycle",n},"LongestCycleCount"],{n,3,20}]

LovaszNumber

seq=Table[GraphData[{"Cycle",n},"LovaszNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

FullSimplify[((n Cos[Pi/n])/(1+Cos[(Pi/n)]))]

Table[Piecewise[{{n/2,Mod[n,2]==0},{((n Cos[Pi/n])/(1+Cos[(Pi/n)])),Mod[n,2]==1}}],{n,3,20}]//FullSimplify

%==seq

LucasCube

Entity["Graph",{"Cycle",n}]["LucasCube"]

seq=Table[GraphData[{"Cycle",n},"LucasCube"],{n,3,20}]

MatchingGeneratingPolynomial

A284967

Same as IndependencePolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"MatchingGeneratingPolynomial"][x],{n,k0=3,20}])//Expand//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[(x^(n/2)) LucasL[n,1/(Sqrt[x])],{n,3,20}]//Expand)//Column

FullSimplify[poly2-poly]

Table[(x^(n/2)) LucasL[n,1/(Sqrt[x])],{n,1,12}]//Expand

CoefficientList[Table[(x^(n/2)) LucasL[n,1/(Sqrt[x])],{n,1,15}],x]

Flatten[%]

(poly3=Table[2(-x)^(n/2)ChebyshevT[n,1/(2 Sqrt[-x])],{n,3,20}]//Expand)//Column

FullSimplify[poly3-poly]

Table[2(-x)^(n/2)ChebyshevT[n,1/(2 Sqrt[-x])]-(x^(n/2)) LucasL[n,1/(Sqrt[x])],{n,10}]//FullSimplify

MatchingNumber

seq=Table[GraphData[{"Cycle",n},"MatchingNumber"],{n,3,20}]

Table[Floor[n/2],{n,3,20}]

MatchingPolynomial

A108045

(poly=Factor@Table[GraphData[{"Cycle",n},"MatchingPolynomial"][x],{n,k0=3,20}])//Column

CoefficientList[poly,x]//Expand//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}]

Flatten[{{1},CoefficientList[LinearRecurrence[{x,-1},{x,-2+(x^2)},10],x]}]

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[I^n LucasL[n,-I x],{n,3,20}]

Flatten[{{0},CoefficientList[Table[I^n LucasL[n,-I x],{n,10}],x]}]

CoefficientList[Table[I^n LucasL[n,-I x],{n,0,10}],x]

FullSimplify[poly2-poly]

MaximalCliqueCount

seq=Table[GraphData[{"Cycle",n},"MaximalCliqueCount"],{n,3,20}]

MaximalIndependentEdgeSetCount

Perrin numbers: A001608

seq=Table[GraphData[{"Cycle",n},"MaximalIndependentEdgeSetCount"],{n,3,20}]

gf=(x^3)FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>2]

Table[RootSum[-1-#+#^3&,#^n&],{n,3,20}]

MaximalIndependentVertexSetCount

Perrin numbers: A001608

seq=Table[GraphData[{"Cycle",n},"MaximalIndependentVertexSetCount"],{n,3,20}]

Table[RootSum[-1-#+#^3&,#^n&],{n,3,20}]

MaximalIrredundantSetCount

A286954

seq=Table[GraphData[{"Cycle",n},"MaximalIrredundantSetCount"],{n,3,20}]

seq={0,2,3,6,10,11,14,14,30,62,66,99,143,212,343,478,697,992,1501,2246,3251,4776,6969,10283,15210,22297,32727,47984,70644,103961,152706,224382,329508,484451,712274,1046736,1538164,2260109,3321932,4882574,7175738,10545581};

Table[GraphData[{"Cycle",n},"IrredundantSets"],{n,3,4}]//Column

Table[GraphData[{"Cycle",n},"MaximalIrredundantSets"],{n,3,4}]//Column

coef=FindLinearRecurrence[seq]

Take[seq,Length@coef]

LinearRecurrence[{0,1,1,1,1,0,-1,-2,-1,2,1,0,0,-1},{0,2,3,6,10,11,14,14,30,62,66,99,143,212},20]

FindSequenceFunction[seq,n]

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

gf=(((x^2) (2+3 x+4 (x^2)+5 (x^3)-7 (x^5)-16 (x^6)-9 (x^7)+20 (x^8)+11 (x^9)-14 (x^12)))/(1-(x^2)-(x^3)-(x^4)-(x^5)+(x^7)+2 (x^8)+(x^9)-2 (x^10)-(x^11)+(x^14)));

CoefficientList[Series[((x(2+3 x+4 (x^2)+5 (x^3)-7 (x^5)-16 (x^6)-9 (x^7)+20 (x^8)+11 (x^9)-14 (x^12)))/(1-(x^2)-(x^3)-(x^4)-(x^5)+(x^7)+2 (x^8)+(x^9)-2 (x^10)-(x^11)+(x^14))),{x,0,20}],x]

Series[gf,{x,0,20}]

res=Refine[SeriesCoefficient[gf,{x,0,n}],n>0]

terms=List@@res;

terms[[All,1]]

N[terms/.n->0]//Chop

approx=RootApproximant[N[exact=terms/.n->0,200],14]

Table[RootSum[1-((#)^3)-2 ((#)^4)+((#)^5)+2 ((#)^6)+((#)^7)-((#)^9)-((#)^10)-((#)^11)-((#)^12)+((#)^14)&,#^n&],{n,20}]

RootSum[1-((#)^3)-2 ((#)^4)+((#)^5)+2 ((#)^6)+((#)^7)-((#)^9)-((#)^10)-((#)^11)-((#)^12)+((#)^14)&,#^Range[20]&]

MaximumCliqueCount

seq=Table[GraphData[{"Cycle",n},"MaximumCliqueCount"],{n,3,20}]

MaximumIndependentEdgeSetCount

seq=Table[GraphData[{"Cycle",n},"MaximumIndependentEdgeSetCount"],{n,3,20}]

Table[Piecewise[{{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],{n,3,20}]

MaximumIndependentVertexSetCount

seq=Table[GraphData[{"Cycle",n},"MaximumIndependentVertexSetCount"],{n,3,20}]

MaximumLeafNumber

seq=Table[GraphData[{"Cycle",n},"MaximumLeafNumber"],{n,3,20}]

MaximumVertexDegree

seq=Table[GraphData[{"Cycle",n},"MaximumVertexDegree"],{n,3,20}]

MeanDistance

seq=Table[GraphData[{"Cycle",n},"MeanDistance"],{n,3,20}]

FullSimplify[FindSequenceFunction[seq,n-2],n∈Integers]

FindGeneratingFunction[seq,x]

MinimalDominatingSetCount

A253413

seq=Table[GraphData[{"Cycle",n},"MinimalDominatingSetCount"],{n,3,20}]

Table[GraphData[{"Cycle",n},"MinimalDominatingSets"],{n,3,6}]//Column

MinimalSets[l_]:=Complement[l,Select[Subsets[l,{2}],Intersection@@#===#[[1]]&][[All,2]]]

SetDirectory[FileNameJoin[{$GraphDataDirectory,"Properties","DominatingSets"}]]

Do[Print[{n,Length@MinimalSets@Import["Cycle-"<>ToString[n]<>".m.gz"]//Timing}],{n,6,19}];//Timing

CycleGraph/@{1,2}

seq={1,2,3,6,5,5,14,14,21,27,44,57,78,114,158,222,306,437,608,851,1193,1674,2346,3281,4605,6450,9039,12662};

FindSequenceFunction[DeleteMissing@seq,n]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

seq=CoefficientList[Series[((1+2 x+2 (x^2)+3 (x^3)-(x^4)-6 (x^5)+(x^6))/(1-(x^2)-(x^3)-(x^4)+(x^6))),{x,0,20}],x]

FindLinearRecurrence[seq]

FindLinearRecurrence[Drop[seq,1]]

Join[{1},LinearRecurrence[{0,1,1,1,0,-1},{0,2,3,6,5,5},{2,20}]]

coef=SeriesCoefficient[gf,{x,0,n}]

c=Refine[coef,n>1]

c2=List@@c/.n->1

v1=N/@c2//Chop

v2=List@@c[[All,1]]/.n->-2.

v1 v2//Chop

Join[{1},Table[RootSum[1-((#1)^2)-((#1)^3)-((#1)^4)+((#1)^6)&,#^n&],{n,2,20}]]

MinimalDominatingSetSignature

(seq=Table[GraphData[{"Cycle",n},"MinimalDominatingSetSignature"],{n,3,20}])//Column

MinimalEdgeCoverCount

Perrin numbers

A001608

== MaximalIndependentEdgeSetCount == MaximalIndependentVertexSetCount == MinimalVertexCoverCount

seq=Table[GraphData[{"Cycle",n},"MinimalEdgeCoverCount"],{n,3,20}]

Table[RootSum[-1-#+#^3&,#^n&],{n,3,20}]

Table[GraphData[{"Cycle",n},"MaximalIndependentEdgeSetCount"],{n,3,20}]

Table[GraphData[{"Cycle",n},"MaximalIndependentVertexSetCount"],{n,3,20}]

Table[GraphData[{"Cycle",n},"MinimalVertexCoverCount"],{n,3,20}]

MinimalEdgeCoverSignature

seq=Table[GraphData[{"Cycle",n},"MinimalEdgeCoverSignature"],{n,3,20}]//Column

MinimumCliqueCoveringCount

seq=Table[GraphData[{"Cycle",n},"MinimumCliqueCoveringCount"],{n,3,20}]

Table[Piecewise[{{1,n==3},{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],{n,3,20}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"Cycle",n},"MinimumConnectedDominatingSetCount"],{n,3,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n-2]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"Cycle",n},"MinimumDistinguishingLabelingCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

gf=(x^3)FindGeneratingFunction[seq,x]

MinimumDominatingSetCount

seq=Table[GraphData[{"Cycle",n},"MinimumDominatingSetCount"],{n,3,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-2]

gf=(x^3)FindGeneratingFunction[seq,x]

seq[[1;;All;;4]]

seq[[2;;All;;4]]

seq[[3;;All;;4]]

Table[Piecewise[{{3,Mod[n,4]==3}},XXX],{n,3,20}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"Cycle",n},"MinimumEdgeCoverCount"],{n,3,20}]

Table[Piecewise[{{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],{n,3,20}]

%==seq

MinimumVertexCoverCount

Same as MaximumIndependentVertexSetCount

seq=Table[GraphData[{"Cycle",n},"MinimumVertexCoverCount"],{n,3,20}]

Table[Piecewise[{{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],{n,3,20}]

MinimumVertexDegree

seq=Table[GraphData[{"Cycle",n},"MinimumVertexDegree"],{n,3,20}]

MolecularTopologicalIndex

seq=Table[GraphData[{"Cycle",n},"MolecularTopologicalIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Nonhamiltonian

Table[GraphData[{"Cycle",n},"Nonhamiltonian"],{n,3,20}]

NormalizedLaplacianMatrix

seq=MatrixForm/@Table[GraphData[{"Cycle",n},"NormalizedLaplacianMatrix"],{n,3,6}]

MatrixForm/@Table[SparseArray[{Band[{1,1}]->1,Band[{1,2}]->-1/2,Band[{2,1}]->-1/2,{1,n}->-1/2,{n,1}->-1/2},n],{n,3,6}]

%==seq

OddChordlessCycleCount

seq=Table[GraphData[{"Cycle",n},"OddChordlessCycleCount"],{n,3,20}]

PathCount

seq=Table[GraphData[{"Cycle",n},"PathCount"],{n,3,20}]

FindLinearRecurrence[DeleteMissing@seq]

FindSequenceFunction[DeleteMissing@seq,n-2]//Factor

gf=(x^3) FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>2]

PathPolynomial

Essentially A003057

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

CoefficientList[poly,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[((n x (-x+(x^n)))/(-1+x)),{n,k0,kmax}]

FullSimplify[poly2-poly]

Pell

Entity["Graph",{"Cycle",n}]["Pell"]

seq=Table[GraphData[{"Cycle",n},"Pell"],{n,3,20}]

PentagonCount

seq=Table[GraphData[{"Cycle",n},"PentagonCount"],{n,3,20}]

Perfect

Table[GraphData[{"Cycle",n},"Perfect"],{n,3,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"Cycle",n},"ProjectivePlaneCrossingNumber"],{n,3,20}]

Radius

seq=Table[GraphData[{"Cycle",n},"Radius"],{n,3,20}]

Table[Floor[n/2],{n,3,20}]

RankPolynomial

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

FullSimplify[poly2-poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"Cycle",n},"RectilinearCrossingNumber"],{n,3,20}]

ReliabilityPolynomial

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

FullSimplify[poly2-poly]

ResistanceMatrix

MatrixForm/@(seq=Table[GraphData[{"Cycle",n},"ResistanceMatrix"],{n,k0=3,6}])

SigmaPolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"SigmaPolynomial"][x],{n,k0=3,20}])//Column

Take[poly,6]//Expand//Column

coef=Factor/@FindLinearRecurrence[poly]

A105794

Table[Exp[-x]Sum[(k-1)^n*x^k/k!,{k,0,∞}],{n,7}]//Column

Sum[(k-1)^n*x^k/k!,{k,0,∞}]

Table[Sum[(x^(n-k))(((-1))^(n-i))Binomial[n,i]StirlingS2[i,k],{i,0,n}],{n,6},{k,2,n}]//Column

Sum[(x^(n-k))(((-1))^(n-i))Binomial[n,i]StirlingS2[i,k],{i,0,n}]

Sum[(((-1))^(n-i))Binomial[n,i]StirlingS2[i,k],{i,0,n}]

A261139

StirPrimedGF[n_,x_]:=x^n/(1+x)*Product[1/(1-j*x),{j,1,n-1}];T[0,0]=1;T[_,0]=T[_,1]=0;T[n_,k_]:=SeriesCoefficient[StirPrimedGF[k,x],{x,0,n}]

Table[T[n,k],{n,0,10},{k,0,n}]

x^n/(1+x)*Product[1/(1-j*x),{j,1,n-1}]//FullSimplify

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

poly2=Table[XXX,{n,3,20}]

FullSimplify[poly2-poly]

Skewness

seq=Table[GraphData[{"Cycle",n},"Skewness"],{n,3,20}]

SpanningTreeCount

seq=Table[GraphData[{"Cycle",n},"SpanningTreeCount"],{n,3,20}]

SquareCount

seq=Table[GraphData[{"Cycle",n},"SquareCount"],{n,3,20}]

StabilityIndex

seq=Table[GraphData[{"Cycle",n},"StabilityIndex"],{n,3,20}]

seq[[2;;All;;2]]

FindSequenceFunction[%,2n+2]//FullSimplify

Table[Piecewise[{{5 Fibonacci[n/2]^2,Mod[n,2]==0},{2,Mod[n,2]==1}}],{n,3,20}]

TopologicalIndex

seq=Table[GraphData[{"Cycle",n},"TopologicalIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]

gf=(x^3)FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

seq=Table[GraphData[{"Cycle",n},"ToroidalCrossingNumber"],{n,3,20}]

Traceable

Table[GraphData[{"Cycle",n},"Traceable"],{n,3,20}]

TriangleCount

seq=Table[GraphData[{"Cycle",n},"TriangleCount"],{n,3,20}]

TuttePolynomial

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

FullSimplify[poly2-poly]

Untraceable

Table[GraphData[{"Cycle",n},"Untraceable"],{n,3,20}]

VertexConnectivity

Table[GraphData[{"Cycle",n},"VertexConnectivity"],{n,3,20}]

VertexCoverCount

same as IndependentVertexSetCount

seq=Table[GraphData[{"Cycle",n},"VertexCoverCount"],{n,3,20}]

Table[LucasL[n],{n,3,20}]

VertexCoverNumber

Related to but not the same as IndependenceNumber

seq=Table[GraphData[{"Cycle",n},"VertexCoverNumber"],{n,3,20}]

Table[Ceiling[n/2],{n,3,20}]

VertexCoverPolynomial

A284966

Same as EdgeCoverPolynomial

(poly=Factor@Table[GraphData[{"Cycle",n},"VertexCoverPolynomial"][x],{n,k0=3,20}])//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[(2^(-n)) ((((x-(Sqrt[x]) (Sqrt[4+x])))^n)+(((x+(Sqrt[x]) (Sqrt[4+x])))^n)),{n,3,20}]//Expand

FullSimplify[poly2-poly]

poly3=Table[(x^(n/2))LucasL[n,(Sqrt[x])],{n,3,20}]//Expand

FullSimplify[poly3-poly]

VertexCount

seq=Table[GraphData[{"Cycle",n},"VertexCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

VertexDegrees

seq=Table[GraphData[{"Cycle",n},"VertexDegrees"],{n,3,5}]

WienerIndex

A034828

seq=Table[GraphData[{"Cycle",n},"WienerIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[(1/16) n (-1+(((-1))^n)+2 (n^2)),{n,3,20}]

Table[Floor[n^2/4]n/2,{n,3,20}]

WienerSumIndex

seq=Table[GraphData[{"Cycle",n},"WienerSumIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]

Table[DifferenceRoot[Function[{\[FormalY],\[FormalN]},{-(2+\[FormalN]) (3+\[FormalN]) (4+\[FormalN])-(((3+\[FormalN]))^2) (4+\[FormalN]) \[FormalY][\[FormalN]]-2 (2+\[FormalN]) (4+\[FormalN]) \[FormalY][1+\[FormalN]]+(2+\[FormalN]) (((3+\[FormalN]))^2) \[FormalY][2+\[FormalN]]==0,\[FormalY][1]==(9/2),\[FormalY][2]==(28/3)}]][-2+n],{n,3,20}]

gf=(x^3)FindGeneratingFunction[seq,x]

GraphData

GraphClassString

GraphClassString[Select[GraphData["Cycle"],GraphData[#,"V"]>0&]]

Unit-Distance embeddings

Solve[1==FullSimplify[Norm[R(Through[{Cos,Sin}[2Pi k/n]]-{1,0})],R>0&&0<k<=n/2&&n>0],R]

C3

g=GraphData[gn={"Cycle",3},"Graph","All"]

GraphData[gn,"Embeddings"]

GraphData[gn,"EmbeddingClasses"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

C4

g=GraphData[gn={"Cycle",4},"Graph","All"]

GraphData[gn,"Embeddings"]

GraphData[gn,"EmbeddingClasses"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

C5

g=GraphData[gn={"Cycle",5},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

(e=GraphData[gn,"Embeddings"])//Column

ϕ==(1+(Sqrt[5]))/2

(Sqrt[5])==2ϕ-1

FunctionExpand[Table[GoldenRatio^n,{n,-5,5}]]//Expand

FullSimplify[e^2/.(Sqrt[5])->2GoldenRatio-1]

GraphData[gn,"EmbeddingClasses"]

l={{gn,{0,ToRadicals@FullSimplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[5,#]&/@Range[2])]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

C6

g=GraphData[gn={"Cycle",6},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

C7

g=GraphData[gn={"Cycle",7},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[7,#]&/@Range[3]

l={{gn={"Cycle",7},{0,FullSimplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[7,#]&/@Range[3])]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C8

g=GraphData[gn={"Cycle",8},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[8,#]&/@Range[3]

RecognizeGraph/@%

l={{gn,{0,FullSimplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[8,#]&/@{1,3})]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C9

g=GraphData[gn={"Cycle",9},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[9,#]&/@Range[4]

RecognizeGraph/@%

l={{gn,{0,FullSimplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[9,#]&/@{1,2,4})]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C10

g=GraphData[gn={"Cycle",10},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[10,#]&/@Range[5]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,ToRadicals@FullSimplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[VertexCount[g[[1]]],#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C11

g=GraphData[gn={"Cycle",n=11},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,FullSimplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C12

g=GraphData[gn={"Cycle",n=12},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,FullSimplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C13

g=GraphData[gn={"Cycle",n=13},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C14

g=GraphData[gn={"Cycle",n=14},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C15

g=GraphData[gn={"Cycle",n=15},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C16

g=GraphData[gn={"Cycle",n=16},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C17

g=GraphData[gn={"Cycle",n=17},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C18

g=GraphData[gn={"Cycle",n=18},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C19

g=GraphData[gn={"Cycle",n=19},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

C20

g=GraphData[gn={"Cycle",n=20},"Graph","All"]

UnitDistanceGraphQ[#,WorkingPrecision->Infinity]&/@g//FullSimplify

GraphData[gn,"Embeddings"]//Column

CycleGraphUnitDistance[n,#]&/@Range[n/2]

RecognizeGraph/@%

p=Flatten[Position[%,gn]]

l={{gn,{0,Simplify[ToCommonEdges[#,GraphData[gn]]&/@(CycleGraphUnitDistance[n,#]&/@p)]}}}

PropertyReplace[l,"Embeddings","11.3"]

RenameGraphFiles[]

GraphData[gn,"EmbeddingClasses"]

GraphDataString

Default names, etc.

GraphData[{"Cycle",19},"StandardNames"]

GraphData[{"Cycle",20},"StandardNames"]

GraphData[{"Cycle",20},"Names"]

GraphData[{"Cycle",20},"Classes"]

GraphData[{"Cycle",19},"NotationRules"]

Intersection@@(GraphData[#,"Classes"]&/@GraphData["Cycle"])

GraphData[{"Cycle",19},"Notation"]//InputForm

Recompute

<<MathWorld`Graphs`

file=OpenAppend["~/cycle.m"]

Added Expand to ConnectedInducedSubgraphPolynomial, PathPolynomial, TuttePolynomial

Table[With[
{
nn=ToString[n],
ci=Map[{n,{#}}&,Select[Range[n/2],CoprimeQ[#,n]&]]
(* CirculantIndices[CycleGraph[n],All] *)
},
WriteString[file,GraphDataString[
g=Quiet@Graph[Range[n],UndirectedEdge@@@Sort[Sort/@Partition[Range[n],2,1,1]],VertexCoordinates->CirclePoints[Csc[Pi/n]/2,n]],

"Skip"->{"ConnectedDominatingSets","ConnectedInducedSubgraphs","DominatingSets","EdgeCovers","GracefulLabelings","IndependentVertexSets","IrredundantSets","MinimalEdgeCovers","MinimalVertexCovers","MinimumCoveringsByMaximalCliques","RadioLabelings"},

"StandardName"->{"Cycle",n},
"AlternateStandardNames"->SortBy[
{{"ArcTransitive",{n,1}},"C"<>nn,Sequence@@({"Circulant",#}&/@ci),If[EvenQ[n],{"Haar",(2^(n/2-1))+1},Sequence@@{}],{"Harary",{2,n}},{"HoneycombToroidal",{1,n,1}},{"Knoedel",{2,n}},{"Wreath",{n,1}}},First[Flatten[{#}]]&
],
"AlternateNames"->Sort[{If[EvenQ[n],ToString[(2^(n/2-1))+1]<>"\[Hyphen]Haar graph",Sequence@@{}],"(1,"<>nn<>",1)\[Hyphen]honeycomb toroidal graph","("<>nn<>",1)\[Hyphen]wreath graph",nn<>"\[Hyphen]arc transitive graph (1)",Function[circ,nn<>"\[Hyphen]circulant graph "<>StringReplace[ToString[circ[[2]]],{"{"->"(","}"->")"}]]/@ci,"(2,"<>nn<>")\[Hyphen]Harary graph","(2,"<>nn<>")\[Hyphen]Knödel graph"}],
"EmbeddingClasses"->{"Circulant","LCF"},
"Information"->"CycleGraph",
"Notation"->Subscript["C",n],
"Name"->nn<>"\[Hyphen]cycle graph",

"Classes"->{"Apex","ArcTransitive","Biconnected","Bridgeless","Cactus","Cayley","Chordless","ChromaticallyUnique","Circulant","ClawFree","Connected","Cycle","Cyclic","DeterminedBySpectrum","DistanceRegular","DistanceTransitive","EdgeTransitive","Eulerian",If[EvenQ[n],"Haar",Sequence@@{}],"HamiltonDecomposable","Hamiltonian","Harary",If[EvenQ[n],"Knoedel",Sequence@@{}],"LCF","Line","Local","Matchstick","Outerplanar","Planar","Pseudoforest","Pseudotree","Regular","Simple","Symmetric","Traceable","TwoRegular","Unicyclic","UnitDistance","VertexTransitive","Wreath"},
"NotationRules"->{"ArcTransitive"->{n,1},"Circulant"->{n,{1}},"Cycle"->n,If[EvenQ[n],"Haar"->(2^(n/2-1))+1,Sequence@@{}],"Harary"->{2,n},"HoneycombToroidal"->{1,n,1},"Knoedel"->{2,n},"Wreath"->{n,1}},

"Anarboricity":>1,
"Arboricity"->2,
"ArcTransitivity":>Infinity,
"AutomorphismCount"->2n,
"BalabanIndex":>Piecewise[{{2,Mod[n,2]==0},{2 n^2/(n^2-1),Mod[n,2]==1}}],
"Bandwidth":>2,
"BipartiteDoubleGraphName":>Which[OddQ[n],{"Cycle",2 n},EvenQ[n],"2C"<>ToString[n],True,Missing["NotAvailable"]],
"BurningNumber":>Ceiling[Sqrt[n]],
"Center":>If[NumericQ[n],Range[n],Missing["NotApplicable"]],"CharacteristicPolynomial":>Function[x,Evaluate@If[NumericQ[n],Factor,Identity][2 (ChebyshevT[n,x/2]-1)]],
"ChordCount":>0,
"ChordlessCycleCount":>Piecewise[{{0,n==3}},1],
"ChordlessCyclePolynomial":>Function[x,Piecewise[{{0,n==3}},x^n]],
"ChordlessCycles":>If[NumericQ[n],Piecewise[{{{},n==3}},UndirectedEdge@@@Partition[Range[n],2,1,1]],Missing["NotApplicable"]],
"Chords":>{},
"ChromaticInvariant":>1,
"ChromaticNumber":>Piecewise[{{2,Mod[n,2]==0},{3,Mod[n,2]==1}}],
"ChromaticPolynomial":>Function[x,Evaluate@If[NumericQ[n],Factor,Identity][(-1)^n (x-1)+(x-1)^n]],
"Circumference":>n,
"CliqueCount":>Piecewise[{{8,n==3}},2 n+1],
"CliqueCoveringNumber":>Piecewise[{{1,n==3}},Ceiling[n/2]],
"CliqueNumber":>Piecewise[{{3,n==3}},2],
"CliquePolynomial":>Function[x,Piecewise[{{(1+x)^3,n==3}},1+n x+n x^2]],
"ComplementOddChordlessCycleCount":>Piecewise[{{1,n==5}},0],
"ComplementOddChordlessCyclePolynomial":>Function[x,Piecewise[{{x^5,n==5}},0]],
"ComplementOddChordlessCycles":>Piecewise[{{{Range[5]},n==5}},{}],"ComplementGraph":>If[NumericQ[n],GraphComplement[CycleGraph[n]],Missing["NotApplicable"]],"ComplementGraphName":>If[NumericQ[n],{"Circulant",{n,Piecewise[{{DeleteCases[Range[n/2],n/2-1],Mod[n,4]==0},{DeleteCases[Range[n/2],n/2-2],Mod[n,4]==2},{Range[(n-3)/2],Mod[n,2]==1}}]}},Missing["NotApplicable"]],
"ConnectedComponentCount":>1,
"ConnectedDominatingSetCount":>2 n+1,
"ConnectedDominationNumber":>n-2,
"ConnectedDominationPolynomial":>Function[x,x^(n-2) (x^2+n x+n)],
"ConnectedInducedSubgraphCount":>n^2-n+1,
"ConnectedInducedSubgraphPolynomial":>Function[x,Expand[x^n+n (x^n-x)/(x-1)]],
"CrossingNumber":>0,
"CycleCount":>1,
"CyclePolynomial":>Function[x,x^n],
"CyclomaticNumber":>1,"DetourIndex":>Piecewise[{{n^2 (3 n-4)/8,Mod[n,2]==0},{(n-1)n(3 n-1)/8,Mod[n,2]==1}}],"DetourMatrix":>If[NumericQ[n],SparseArray[{{i_,i_}->0,{i_,j_}:>If[Abs[i-j]<n/2,n-Abs[i-j],Abs[i-j]]},n],Missing["NotApplicable"]],
"Diameter":>Floor[n/2],
"Dimension":>2,
"DistanceMatrix":>If[NumericQ[n],ToeplitzMatrix[Join[Range[0,Floor[n/2]],Range[Floor[(n-1)/2],1,-1]],SparseArray],Missing["NotApplicable"]],
"DistancePolynomial":>Function[x,Evaluate@If[NumericQ[n],Factor,Identity][Piecewise[{{(4 x-n^2) x^(n-1) (I^n ChebyshevT[n,I/Sqrt[x]]+1)/8,Mod[n,2]==0},{(4 x-n^2+1) x^(n-1) Fibonacci[n,1/Sqrt[x]]^2/4,Mod[n,2]==1}}]]],
"DistinguishingNumber":>Piecewise[{{3,n==3||n==4||n==5},{2,n>=6}}],
"DomaticNumber":>Piecewise[{{3,Mod[n,3]==0}},2],
"DominatingSetCount":>RootSum[-1-#-#^2+#^3&,#^n&],
"DominationNumber":>Floor[(n+2)/3],
"DominationPolynomial":>If[NumericQ[n],Function[x,MyLinearRecurrence[{x,x,x},{x,2 x+x^2,3 x+3 x^2+x^3},{n}][[1]]],Missing["NotAvailable"]],
"Eccentricities":>If[NumericQ[n],ConstantArray[Floor[n/2],n],Missing["NotApplicable"]],"EdgeChromaticNumber":>Piecewise[{{3,Mod[n,2]==1},{2,Mod[n,2]==0}}],
"EdgeConnectivity":>2,
"EdgeCount":>n,
"EdgeCoverCount":>LucasL[n],
"EdgeCoverNumber":>Ceiling[n/2],
"EdgeCoverPolynomial":>Function[x,Evaluate@If[NumericQ[n],Expand,Identity][x^(n/2) LucasL[n,Sqrt[x]]]],
"Edges":>If[NumericQ[n],UndirectedEdge@@@Sort[Sort/@Partition[Range[n],2,1,1]],Missing["NotApplicable"]],
"EulerianCycleCount":>1,
"FaceCount":>2,
"FaceIndices"->{Range[n],Range[n,1,-1]},
"FaceSignature":>{{n,2}},
 "FlowPolynomial":>Function[x,x-1],
"FractionalChromaticNumber":>Piecewise[{{2,Mod[n,2]==0},{(2 n)/(n-1),Mod[n,2]==1}}],"FractionalEdgeChromaticNumber":>Piecewise[{{2,Mod[n,2]==0},{(2 n)/(n-1),Mod[n,2]==1}}],
"Genus":>0,
"Girth":>n,
"GlobalClusteringCoefficient":>Piecewise[{{1,n==3}},0],
"Graceful":>Piecewise[{{True,Mod[n,4]==0||Mod[n,4]==3},{False,Mod[n,4]==1||Mod[n,4]==2}}],
"GracefulLabeling":>Which[!NumericQ[n],Missing["NotApplicable"],Mod[n,4]==0||Mod[n,4]==3,Missing["NotAvailable",With[{mod4=Mod[n,4]},Table[Switch[mod4,0,Piecewise[{{i/2,Mod[i,2]==0},{n-(i-1)/2,i<=n/2-1},{n-(i-1)/2-1,i>=n/2+1}}],3,Piecewise[{{i/2,Mod[i,2]==0},{n-(i-1)/2,i<=(n+1)/2-1},{n-(i-1)/2-1,i>=(n+1)/2+1}}]],{i,0,n-1}]]][[2]],Mod[n,4]==1||Mod[n,4]==2,{}],"Graph":>If[NumericQ[n],CycleGraph[n],Missing["NotApplicable"]],"HamiltonConnected":>Piecewise[{{True,n==3}},False],
"GracefulLabelingCount"->If[n<=26,{0,0,12,16,0,0,168,384,0,0,4576,11808,0,0,232920,654848,0,0,16141792,48181600,0,0,1540635588,5155171200,0,0}[[n]]/(4n),Missing["NotAvailable"]],
"HamiltonDecompositionCount":>1,
"HamiltonianCycleCount":>1,
"HamiltonianNumber":>n,
"HamiltonianPathCount":>n,
"HamiltonianPaths":>If[NumericQ[n],SimplePaths[Partition[Range[n],n,1,1]],Missing["NotApplicable"]],
"HamiltonianWalkCount":>1,
"HararyIndex":>(1+(-1)^n)/2+n HarmonicNumber[Floor[(n-1)/2]],
"HexagonCount":>Piecewise[{{1,n==6}},0],"IdiosyncraticPolynomial":>If[NumericQ[n],Function[{x,y},Evaluate@Factor@MyLinearRecurrence[{-2 (1+x),-(1+x) (3+x-2 y),2 (-1+y) (2+2 x+x^2-2 y+y^2),-(1+x) (3+x-2 y) (-1+y)^2,-2 (1+x) (-1+y)^4,-(-1+y)^6},{2-x-2 y,x^2-(-2+y)^2,2+3 x-x^3,(-2+x-y) (2+x-y) (x+y)^2,-(-2+x-2 y) (-1+x+x^2+3 y+x y-y^2)^2,(1+x)^2 (-2+x-3 y) (2+x-y) (-1+x+2 y)^2},{n}][[1]]],Missing["NotAvailable"]],"IncidenceMatrix":>If[NumericQ[n],IncidenceMatrix[CycleGraph[n]],Missing["NotApplicable"]],
"IndependenceNumber":>Floor[n/2],
"IndependencePolynomial":>Function[x,Evaluate@If[NumericQ[n],Expand,Identity][x^(n/2) LucasL[n,1/Sqrt[x]]]],
"IndependenceRatio":>Floor[n/2]/n,
"IndependentEdgeSetCount":>LucasL[n],
"IndependentVertexSetCount":>LucasL[n],
"IntersectionArray":>Which[OddQ[n],{Prepend[ConstantArray[1,(n-3)/2],2],ConstantArray[1,(n-1)/2]},EvenQ[n],{Prepend[ConstantArray[1,n/2-1],2],Append[ConstantArray[1,n/2-1],2]},True,Missing["NotApplicable"]],
"IntersectionNumber":>Missing["NotAvailable"],
"IrredundanceNumber":>Floor[(n+2)/3],"IrredundancePolynomial":>If[NumericQ[n],Function[x,MyLinearRecurrence[{1,x,0,x^2,0,-x^3},{1,1+2 x,1+3 x,1+4 x+6 x^2,1+5 x+10 x^2,1+6 x+15 x^2+2 x^3},{n}][[1]]],Missing["NotAvailable"]],
"IrredundantSetCount":>RootSum[1-#^2-#^4-#^5+#^6&,#^n&],
"IsolatedPointCount":>0,
"IsolatedPoints":>{},
"KirchhoffIndex":>Binomial[n+1,3]/2,
"KirchhoffSumIndex":>(1-(-1)^n-8 n+6 n^2)/16,"LaplacianMatrix":>If[NumericQ[n],SparseArray[{Band[{1,2}]->-1,Band[{1,1}]->2,Band[{2,1}]->1,Band[{1,n}]->-1,Band[{n,1}]->-1}],Missing["NotApplicable"]],"LaplacianPolynomial":>Function[x,Evaluate@If[NumericQ[n],Expand,Identity][LucasL[2 n,Sqrt[-x]]-2]],
"LeafCount":>0,
"Leaves":>{},
"LongestCycleCount":>1,
"LongestPathCount":>n,
"LongestPathLength":>n-1,
"LovaszNumber":>Piecewise[{{n/2,Mod[n,2]==0},{(n Cos[Pi/n])/(1+Cos[Pi/n]),Mod[n,2]==1}}],
"LowerIndependenceNumber":>Floor[(n+2)/3],
"LowerMatchingNumber":>Floor[(n+2)/3],
"MatchingGeneratingPolynomial":>Function[x,Evaluate@If[NumericQ[n],Expand,Identity][x^(n/2) LucasL[n,1/Sqrt[x]]]],
"MatchingNumber":>Floor[(n+2)/3],
"MatchingPolynomial":>Function[x,Evaluate@If[NumericQ[n],Expand,Identity][I^n LucasL[n,-I x]]],
"MaximalCliqueCount":>Piecewise[{{1,n==3}},n],
"MaximalCliquePolynomial":>Function[x,Piecewise[{{x^3,n==3}},n x^2]],
"MaximalIndependencePolynomial":>If[NumericQ[n],Function[x,MyLinearRecurrence[{0,x,x},{0,2 x,3 x},{n}][[1]]],(*Else*)Missing["NotAvailable"]],
"MaximalIndependentEdgeSetCount":>RootSum[-1-#+#^3&,#^n&],
"MaximalIndependentVertexSetCount":>RootSum[-1-#+#^3&,#^n&],
"MaximalIrredundantSetCount":>RootSum[1-#^3-2 #^4+#^5+2 #^6+#^7-#^9-#^10-#^11-#^12+#^14&,#^n&],"MaximalMatchingGeneratingPolynomial":>If[NumericQ[n],Function[x,MyLinearRecurrence[{0,x,x},{0,2 x,3 x},{n}][[1]]],(*Else*)Missing["NotAvailable"]],
"MaximumCliqueCount":>Piecewise[{{1,n==3}},n],
"MaximumIndependentEdgeSetCount":>Piecewise[{{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],"MaximumIndependentVertexSetCount":>Piecewise[{{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],"MaximumIrredundantSetCount":>Piecewise[{{6,Mod[n,4]==0},{n (n+3)/4,Mod[n,4]==1},{2,Mod[n,4]==2},{n (n+1)/4,Mod[n,4]==3}}],"MaximumLeafNumber":>2,
"MaximumVertexDegree":>2,
"MeanClusteringCoefficient":>Piecewise[{{1,n==3}},0],
"MeanDistance":>(-1+(-1)^n+2 n^2)/(8 n),
"MetricDimension":>2,
"MinimalConnectedDominatingSetCount":>Piecewise[{{3,n==1},{4,n==2}},0],
"MinimalConnectedDominationPolynomial":>Function[x,Piecewise[{{3 x,n==3},{4 x^2,n==4}},0]],"MinimalDominatingSetCount":>RootSum[1-#^2-#^3-#^4+#^6&,#^n&],"MinimalDominationPolynomial":>If[NumericQ[n],Function[x,MyLinearRecurrence[{0,x,x,x^2,0,-x^3},{0,2 x,3 x,6 x^2,5 x^2,x^2 (3+2 x)},{n}][[1]]],(*Else*)Missing["NotAvailable"]],
"MinimalEdgeCoverCount":>RootSum[-1-#+#^3&,#^n&],"MinimalEdgeCoverPolynomial":>If[NumericQ[n],Function[x,MyLinearRecurrence[{0,x,x^2},{0,2x,3 x^2},{n}][[1]]],(*Else*)Missing["NotAvailable"]],
"MinimalTotalDominatingSetCount":>RootSum[-1-#+#^3&,#^n&]+(1+(-1)^n) RootSum[-1+#^2+#^3&,#^(n/2)&],
"MinimalVertexCoverPolynomial":>If[NumericQ[n],Function[x,MyLinearRecurrence[{0,x,x^2},{0,2 x,3 (x^2)},{n}][[1]]],Missing["NotAvailable"]],"MinimumCoveringsByMaximalCliquesCount":>Piecewise[{{1,n==3},{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],
"MinimumConnectedDominatingSetCount":>n,
"MinimumDominatingSetCount":>Piecewise[{{3,Mod[n,3]==0},{n (n+5)/6,Mod[n,3]==1},{n,Mod[n,3]==2}}],"MinimumEdgeCoverCount":>Piecewise[{{2,Mod[n,2]==0},{n,Mod[n,2]==1}}],"MinimumTotalDominatingSetCount":>((-1)^n (n-4)^2+(n+4)^2-2 (n^2-16) Cos[n Pi/2])/16,
"MinimumVertexCutCount":>n (n-3)/2,
"MinimumVertexDegree":>2,
"MolecularTopologicalIndex":>n (15+(-1)^n+2 n^2)/4,"NormalizedLaplacianMatrix":>If[NumericQ[n],SparseArray[{Band[{1,1}]->1,Band[{1,2}]->-1/2,Band[{2,1}]->-1/2,{1,n}->-1/2,{n,1}->-1/2},n],Missing["NotApplicable"]],
"OddChordlessCycleCount":>Piecewise[{{0,n==3||Mod[n,2]==0},{1,Mod[n,2]==1}}],"OddChordlessCycles":>If[NumericQ[n],Piecewise[{{{},n==3||Mod[n,2]==0},{Range[n],Mod[n,2]==1}}],Missing["NotAvailable"]],
"PathCount":>n (n-1),
"PathPolynomial":>Function[x,Expand[(n x (x^n-x))/(x-1)]],
"PebblingNumber":>Piecewise[{{2^(n/2),Mod[n,2]==0},{Ceiling[(2^((n+3)/2)-1)/3],Mod[n,2]==1}}],
"PentagonCount":>Piecewise[{{1,n==5}},0],"Perfect":>Piecewise[{{True,n==3},{True,Mod[n,2]==0},{False,Mod[n,2]==1}}],"Periphery":>If[NumericQ[n],Range[n],Missing["NotApplicable"]],
"ProjectivePlaneCrossingNumber":>0,
"RadioNumber":>Piecewise[{{(n-2)/2 Floor[n/4]+n-1,Mod[n,2]==0},{(n+3) (n-1)/8,Mod[n,4]==1},{(n-1)/2 (Floor[n/4]+2),Mod[n,2]==1}}],
"Radius":>Floor[n/2],
"RankPolynomial":>Function[{x,y},(x^(n-1) (y-x)+(x+1)^n)],
"RectilinearCrossingNumber":>0,
"ReliabilityPolynomial":>Function[x,(1-x)^(n-1) (1+(n-1) x)],
"Skewness":>0,
"SpanningTreeCount":>n,
"SpectralRadius":>2,
"Spectrum":>Missing["NotAvailable"],
"SquareCount":>Piecewise[{{1,n==4}},0],"StabilityIndex":>Piecewise[{{5 Fibonacci[n/2]^2,Mod[n,2]==0},{2,Mod[n,2]==1}}],
"SymmetricallyDistinctVertexPairCount":>Floor[n/2],"SymmetricallyDistinctVertexPairSignature":>If[NumericQ[n],Piecewise[{{Table[{{1,k},n},{k,2,Ceiling[n/2]}],Mod[n,2]==1},{Join[Table[{{1,k},n},{k,2,Ceiling[n/2]}],{{{1,n/2+1},n/2}}],Mod[n,2]==0}}],Missing["NotApplicable"]],
"ToroidalCrossingNumber":>0,
"TotalDominatingSetCount":>LucasL[n]+2 Cos[n Pi/2],
"TotalDominationNumber":>(1+n-Cos[n Pi/2])/2,
"TotalDominationPolynomial":>Function[x,Expand[x^(n/2) (2 Cos[n Pi/2]+LucasL[n,Sqrt[x]])]],
"Treewidth":>2,
"Triameter":>n,
"TriangleCount":>Piecewise[{{1,n==3}},0],
"TuttePolynomial":>Function[{x,y},Expand[(x^n-x)/(x-1)+y]],
"UpperDominationNumber":>Floor[n/2],
"UpperIrredundanceNumber":>Floor[n/2],
"VertexConnectivity":>2,
"VertexCount":>n,
"VertexCoverNumber":>Ceiling[n/2],
"VertexCoverPolynomial":>Function[x,Evaluate@If[NumericQ[n],Expand,Identity][x^(n/2) LucasL[n,Sqrt[x]]]],
"VertexDegrees":>If[NumericQ[n],ConstantArray[2,n],Missing["NotApplicable"]],
"WienerIndex":>Piecewise[{{n^3/8,Mod[n,2]==0},{3/4 Binomial[n+1,3],Mod[n,2]==1}}],
"WienerSumIndex":>n^2 (HarmonicNumber[2 Floor[n/2]]-HarmonicNumber[Floor[n/2]]),
Debug->True]]],
{n,30,30}]

Close[file]