Book Graph

Author

Eric W. Weisstein
September 17, 2024

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

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

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

Graphics

Graphs.m

GraphicsRow[Table[Show[BookGraph[n]//StyleGraphs,PlotLabel->Style[Subscript[B,n],FontFamily->"Times"]],{n,6}],ImageSize->500,Dividers->All]

GraphData

GraphicsRow[Table[Show[GraphData[{"Book",n}]//StyleGraphs,PlotLabel->Style[Subscript[B,n],FontFamily->"Times"]],{n,6}],ImageSize->500,Dividers->All]

Combinatorica

GraphicsRow[CombinatoricaGraphToV8Graph[#,VertexSize->{"Scaled",.07},System`VertexStyle->Red,System`EdgeStyle->Black]&/@Table[GraphProduct[Star[n+1],Path[n]],{n,6}],Dividers->All,ImageSize->500]

Special cases

With[{cl="Book"},TextGrid[Sort[{cl/.GraphData[#,"NotationRules"],GraphData[#,"Name"]}&/@DeleteCases[GraphData[cl],{cl,_}]],Dividers->All]]

Embedding types

2D

BookGraph[6,VertexLabels->"Name"]

BookGraph[6,VertexCoordinates->Automatic,VertexLabels->"Name"]

Graph[EdgeList[BookGraph[6]],VertexLabels->"Name"]

Table[GraphData[{"Book",n},"Graph",{"All","Labeled"}],{n,2,20}]

Table[Graph[EdgeList[GraphData[{"Book",n},"Graph"]]],{n,2,20}]

UnitDistance

Table[GraphData[{"Book",n},"Graph","UnitDistance"],{n,20}]

Table[GraphData[{"Book",n},"Graph","UnitDistance"],{n,20}]

3D

Graph3D[BookGraph[6,VertexCoordinates->Automatic,VertexLabels->"Name"]]

Embeddings

<<MathWorld`Graphs`

{"Book", 1} == "SquareGraph"

Names

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

GraphData[{"Book",1},"StandardNames"]

{"Book", 2} == "DominoGraph"

Names

GraphData[{"Book",2},"StandardName"]

GraphData[{"Book",2},"StandardNames"]

{"Book", 3}

Names

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

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

Primary

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

Construction

Table[BookGraph[3,GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",3}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",3},"VertexList"],GraphData[{"Book",3},"Edges"]],GraphLayout->"TutteEmbedding"]

RotateGraph[GraphicsToGraph@,-Pi/6]

Mean[v[[{5,6}]]][[2]]

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

GraphPlot[Graph[GraphData[{"Book",3},"VertexList"],GraphData[{"Book",3},"Edges"]]]

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

RecognizeGraph@g

RegionIntersection[Line[{v[[3]],v[[3]]+v[[6]]-v[[2]]}],Line@v[[{4,6}]]]

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

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

RotateGraph[Graph[Graph[GraphData[{"Book",3},"VertexList"],GraphData[{"Book",3},"Edges"]],GraphLayout->"CircularEmbedding"],5Pi/8]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"Book",3},"Hamiltonian"]

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",3}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

GraphData[{"Book",3},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",3},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",3},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",3},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

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

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

MinimalLocalCrossing construction

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",3},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",3},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

GraphData[{"Book",3},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",3}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",3},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[3,GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 4}

Names

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

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

Primary

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

Construction

Table[BookGraph[4,GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",4}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",4},"VertexList"],GraphData[{"Book",4},"Edges"]],GraphLayout->"TutteEmbedding"]

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

v[[6,2]]

RecognizeGraph@g

GraphPlot[Graph[GraphData[{"Book",4},"VertexList"],GraphData[{"Book",4},"Edges"]]]

RotateGraph[Graph[Graph[GraphData[{"Book",4},"VertexList"],GraphData[{"Book",4},"Edges"]],GraphLayout->"CircularEmbedding"],7Pi/10]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"Book",4},"Hamiltonian"]

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",4}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

GraphData[{"Book",4},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",4},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",4},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",4},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

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

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

MinimalLocalCrossing construction

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",4},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",4},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

GraphData[{"Book",4},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",4}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",4},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",4}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 5}

Names

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

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

Primary

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

Construction

Table[BookGraph[5,GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",5}]]

Default embedding

g0=RotateGraph[Graph[Graph[GraphData[{"Book",5},"VertexList"],GraphData[{"Book",5},"Edges"]],GraphLayout->"CircularEmbedding",VertexLabels->Automatic],{1,7}]

v=CirclePoints[12][[InversePermutation@{7,12,11,5,10,4,9,3,8,2,6,1}]];
g=Graph[Range@Length@v,EdgeList[g0],VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",5}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",5}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",5}]])//Timing

Length[plemb]

GraphData[{"Book",5},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",5},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",5},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",5},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

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

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

MinimalLocalCrossing construction

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",5},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",5},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

GraphData[{"Book",5},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",5}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",5},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",5}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 6}

Names

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

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

Primary

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

Construction

Table[BookGraph[6,GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",6}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",6},"VertexList"],GraphData[{"Book",6},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",6}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",6}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",6}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",6}]])//Timing

Length[plemb]

GraphData[{"Book",6},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",6},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",6},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",6},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

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

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

MinimalLocalCrossing construction

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",6},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Book",6},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",6}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 7}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",7}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",7}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",7},"VertexList"],GraphData[{"Book",7},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

GraphData[{"Book",7},"Graph","Bilateral"]//StyleGraphs

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",7}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",7}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",7}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",7}]])//Timing

Length[plemb]

GraphData[{"Book",7},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalLocalCrossing

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

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

Circulant

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

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

Circulant construction

GraphData[{"Book",7},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",7}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",7},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",7}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 8}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",8}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",8}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",8},"VertexList"],GraphData[{"Book",8},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

GraphData[{"Book",8},"Graph","Bilateral"]//StyleGraphs

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",8}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",8}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",8}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",8}]])//Timing

Length[plemb]

GraphData[{"Book",8},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalLocalCrossing

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

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

Circulant

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

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

Circulant construction

GraphData[{"Book",8},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",8}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",8},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",8}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 9}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",9}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",9}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",9},"VertexList"],GraphData[{"Book",9},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

GraphData[{"Book",9},"Graph","Bilateral"]//StyleGraphs

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",9}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",9}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",9}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",9}]])//Timing

Length[plemb]

GraphData[{"Book",9},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalLocalCrossing

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

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

Circulant

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

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

Circulant construction

GraphData[{"Book",9},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",9}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",9},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",9}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 10}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",10}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",10}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",10},"VertexList"],GraphData[{"Book",10},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",10}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",10}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",10}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",10}]])//Timing

Length[plemb]

GraphData[{"Book",10},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalLocalCrossing

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

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

Circulant

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

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

Circulant construction

GraphData[{"Book",10},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",10}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",10},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",10}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 11}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",11}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",11}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",11},"VertexList"],GraphData[{"Book",11},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

GraphData[{"Book",11},"Graph","Bilateral"]//StyleGraphs

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",11}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",11}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",11}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",11}]])//Timing

Length[plemb]

GraphData[{"Book",11},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalLocalCrossing

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

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

Circulant

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

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

Circulant construction

GraphData[{"Book",11},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",11}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",11},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",11}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 12}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",12}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",12}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",12},"VertexList"],GraphData[{"Book",12},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",12}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",12}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",12}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",12}]])//Timing

Length[plemb]

GraphData[{"Book",12},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalLocalCrossing

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

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

Circulant

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

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

Circulant construction

GraphData[{"Book",12},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",12}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",12},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",12}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 13}

Names

GraphData[{"Book",13},"StandardName"]

GraphData[{"Book",13},"StandardNames"]

Primary

GraphData[{"Book",13}]//StyleGraphs[#,ImageSize->Small]&

Construction

gs=Table[BookGraph[{"Book",13}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

GraphData[{"Book",13},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",13}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",13},"VertexList"],GraphData[{"Book",13},"Edges"]]]

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

RecognizeGraph@g

Degenerate

GraphData[{"Book",13},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Book",13},"Graph","Degenerate"]

Configuration

GraphData[{"Book",13},"Configuration"]

GraphData[{"Book",13},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Book",13},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Book",13},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Book",13},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Book",13},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Book",13},"Graph","Bilateral"]//StyleGraphs

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

Circular

GraphData[{"Book",13},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Book",13},"Hamiltonian"]

GraphData[{"Book",13},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Book",13}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",13}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

GraphData[{"Book",13},"Planar"]

GraphData[{"Book",13},"Graph","Planar"]//StyleGraphs

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",13}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",13}]])//Timing

Length[plemb]

GraphData[{"Book",13},"PlanarEmbeddingCount"]

MinimalCrossing

GraphData[{"Book",13},{"RCN","CN"}]

GraphData[{"Book",13},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Book",13},"LocalCrossingNumber"]

GraphData[{"Book",13},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Book",13},"Circulant"]

GraphData[{"Book",13},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Book",13},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",13}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",13},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Book",13},"ComplementGraph","Name"]

Line graph

GraphData[{"Book",13},"Line"]

LineGraphQ[GraphData[{"Book",13}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Book",13}&]

RootGraph[GraphData[{"Book",13}]]

RecognizeGraph[%]

Halin

GraphData[{"Book",13},"Halin"]

GraphData[{"Book",13},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Book",13},"Rigid"]

GraphData[{"Book",13},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Book",13},"Flexible"]

GraphData[{"Book",13},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Book",13},"LCF"]

GraphData[{"Book",13},"HamiltonianCycleCount"]

GraphData[{"Book",13},"LCFSignature"]

GraphData[{"Book",13},"LCFNotations"]

GraphData[{"Book",13},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"Book",13},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Book",13}],Debug->True]//Timing

GraphData[{"Book",13},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Book",13},"VertexList"],GraphData[{"Book",13},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Book",13},"Matchstick"]

GraphData[{"Book",13},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Book",13},"Edges"]]

3D construction

g=BookGraph[{"Book",13}[[2]],GraphLayout->"3DEmbedding"]

3D All

GraphData[{"Book",13},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Book",13},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Book",13},"Polyhedral"]

GraphData[{"Book",13},"Graph",{"3D","Polyhedron"}]

{"Book", 14}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",14}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",14}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",14},"VertexList"],GraphData[{"Book",14},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"Book",14},"Hamiltonian"]

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

Length[hc=FindHamiltonianCycle[GraphData[{"Book",14}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",14}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",14}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",14}]])//Timing

Length[plemb]

GraphData[{"Book",14},"PlanarEmbeddingCount"]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"Book",14},"LocalCrossingNumber"]

GraphData[{"Book",14},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

GraphData[{"Book",14},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",14}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",14},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

g=BookGraph[{"Book",14}[[2]],GraphLayout->"3DEmbedding"]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Book", 15}

Names

GraphData[{"Book",15},"StandardName"]

GraphData[{"Book",15},"StandardNames"]

Primary

GraphData[{"Book",15}]//StyleGraphs[#,ImageSize->Small]&

Construction

gs=Table[BookGraph[{"Book",15}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

GraphData[{"Book",15},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",15}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",15},"VertexList"],GraphData[{"Book",15},"Edges"]]]

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

RecognizeGraph@g

Degenerate

GraphData[{"Book",15},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Book",15},"Graph","Degenerate"]

Configuration

GraphData[{"Book",15},"Configuration"]

GraphData[{"Book",15},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Book",15},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Book",15},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Book",15},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Book",15},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Book",15},"Graph","Bilateral"]//StyleGraphs

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

Circular

GraphData[{"Book",15},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Book",15},"Hamiltonian"]

GraphData[{"Book",15},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Book",15}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",15}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

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

quad

Planar

GraphData[{"Book",15},"Planar"]

GraphData[{"Book",15},"Graph","Planar"]//StyleGraphs

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Book",15}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",15}]])//Timing

Length[plemb]

GraphData[{"Book",15},"PlanarEmbeddingCount"]

MinimalCrossing

GraphData[{"Book",15},{"RCN","CN"}]

GraphData[{"Book",15},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Book",15},"LocalCrossingNumber"]

GraphData[{"Book",15},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Book",15},"Circulant"]

GraphData[{"Book",15},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Book",15},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",15}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",15},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Book",15},"ComplementGraph","Name"]

Line graph

GraphData[{"Book",15},"Line"]

LineGraphQ[GraphData[{"Book",15}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Book",15}&]

RootGraph[GraphData[{"Book",15}]]

RecognizeGraph[%]

Halin

GraphData[{"Book",15},"Halin"]

GraphData[{"Book",15},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Book",15},"Rigid"]

GraphData[{"Book",15},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Book",15},"Flexible"]

GraphData[{"Book",15},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Book",15},"LCF"]

GraphData[{"Book",15},"HamiltonianCycleCount"]

GraphData[{"Book",15},"LCFSignature"]

GraphData[{"Book",15},"LCFNotations"]

GraphData[{"Book",15},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"Book",15},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Book",15}],Debug->True]//Timing

GraphData[{"Book",15},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Book",15},"VertexList"],GraphData[{"Book",15},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"Book",15},"Matchstick"]

GraphData[{"Book",15},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Book",15},"Edges"]]

3D construction

g=BookGraph[{"Book",15}[[2]],GraphLayout->"3DEmbedding"]

3D All

GraphData[{"Book",15},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Book",15},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Book",15},"Polyhedral"]

GraphData[{"Book",15},"Graph",{"3D","Polyhedron"}]

{"Book", 16}

Names

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

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

Primary

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

Construction

gs=Table[BookGraph[{"Book",16}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Book",16}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",16},"VertexList"],GraphData[{"Book",16},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

Configuration

GraphData[{"Book",16},"Configuration"]

GraphData[{"Book",16},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Book",16},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Book",16},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Book",16},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Book",16},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Book",16},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Book",16},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Book",16},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Book",16},"Hamiltonian"]

GraphData[{"Book",16},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Book",16}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",16}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"Book",16},"Planar"]

GraphData[{"Book",16},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Book",16}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Book",16}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",16}]])//Timing

Length[plemb]

GraphData[{"Book",16},"PlanarEmbeddingCount"]

MinimalCrossing

GraphData[{"Book",16},{"RCN","CN"}]

GraphData[{"Book",16},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Book",16},"LocalCrossingNumber"]

GraphData[{"Book",16},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Book",16},"Circulant"]

GraphData[{"Book",16},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Book",16},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",16}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",16},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Book",16},"ComplementGraph","Name"]

Line graph

GraphData[{"Book",16},"Line"]

LineGraphQ[GraphData[{"Book",16}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Book",16}&]

RootGraph[GraphData[{"Book",16}]]

RecognizeGraph[%]

Halin

GraphData[{"Book",16},"Halin"]

GraphData[{"Book",16},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Book",16},"Rigid"]

GraphData[{"Book",16},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Book",16},"Flexible"]

GraphData[{"Book",16},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Book",16},"LCF"]

GraphData[{"Book",16},"HamiltonianCycleCount"]

GraphData[{"Book",16},"LCFSignature"]

GraphData[{"Book",16},"LCFNotations"]

GraphData[{"Book",16},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Book",16},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Book",16}],Debug->True]//Timing

GraphData[{"Book",16},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Book",16},"VertexList"],GraphData[{"Book",16},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Book",16},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Book",16}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Book",16}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Book",16},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Book",16}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Matchstick

GraphData[{"Book",16},"Matchstick"]

GraphData[{"Book",16},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Book",16},"Edges"]]

3D construction

g=BookGraph[{"Book",16}[[2]],GraphLayout->"3DEmbedding"]

3D All

GraphData[{"Book",16},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Book",16},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Book",16},"Polyhedral"]

GraphData[{"Book",16},"Graph",{"3D","Polyhedron"}]

{"Book", 17}

Names

GraphData[{"Book",17},"StandardName"]

GraphData[{"Book",17},"StandardNames"]

Primary

GraphData[{"Book",17}]//StyleGraphs[#,ImageSize->Small]&

Construction

gs=Table[BookGraph[{"Book",17}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

GraphData[{"Book",17},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Book",17},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Book",17}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",17},"VertexList"],GraphData[{"Book",17},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

Degenerate

GraphData[{"Book",17},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Book",17},"Graph","Degenerate"]

Configuration

GraphData[{"Book",17},"Configuration"]

GraphData[{"Book",17},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Book",17},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Book",17},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Book",17},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Book",17},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Book",17},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Book",17},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Book",17},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Book",17},"Hamiltonian"]

GraphData[{"Book",17},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Book",17}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",17}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"Book",17},"Planar"]

GraphData[{"Book",17},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Book",17}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Book",17}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",17}]])//Timing

Length[plemb]

GraphData[{"Book",17},"PlanarEmbeddingCount"]

MinimalCrossing

GraphData[{"Book",17},{"RCN","CN"}]

GraphData[{"Book",17},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Book",17},"LocalCrossingNumber"]

GraphData[{"Book",17},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Book",17},"Circulant"]

GraphData[{"Book",17},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Book",17},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",17}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",17},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Book",17},"ComplementGraph","Name"]

Line graph

GraphData[{"Book",17},"Line"]

LineGraphQ[GraphData[{"Book",17}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Book",17}&]

RootGraph[GraphData[{"Book",17}]]

RecognizeGraph[%]

Halin

GraphData[{"Book",17},"Halin"]

GraphData[{"Book",17},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Book",17},"Rigid"]

GraphData[{"Book",17},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Book",17},"Flexible"]

GraphData[{"Book",17},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Book",17},"LCF"]

GraphData[{"Book",17},"HamiltonianCycleCount"]

GraphData[{"Book",17},"LCFSignature"]

GraphData[{"Book",17},"LCFNotations"]

GraphData[{"Book",17},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Book",17},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Book",17}],Debug->True]//Timing

GraphData[{"Book",17},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Book",17},"VertexList"],GraphData[{"Book",17},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Book",17},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Book",17}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Book",17}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Book",17},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Book",17}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Matchstick

GraphData[{"Book",17},"Matchstick"]

GraphData[{"Book",17},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Book",17},"Edges"]]

3D construction

g=BookGraph[{"Book",17}[[2]],GraphLayout->"3DEmbedding"]

3D All

GraphData[{"Book",17},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Book",17},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Book",17},"Polyhedral"]

GraphData[{"Book",17},"Graph",{"3D","Polyhedron"}]

{"Book", 18}

Names

GraphData[{"Book",18},"StandardName"]

GraphData[{"Book",18},"StandardNames"]

Primary

GraphData[{"Book",18}]//StyleGraphs[#,ImageSize->Small]&

Construction

gs=Table[BookGraph[{"Book",18}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

GraphData[{"Book",18},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Book",18},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Book",18}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",18},"VertexList"],GraphData[{"Book",18},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

Degenerate

GraphData[{"Book",18},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Book",18},"Graph","Degenerate"]

Configuration

GraphData[{"Book",18},"Configuration"]

GraphData[{"Book",18},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Book",18},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Book",18},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Book",18},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Book",18},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Book",18},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Book",18},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Book",18},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Book",18},"Hamiltonian"]

GraphData[{"Book",18},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Book",18}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",18}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"Book",18},"Planar"]

GraphData[{"Book",18},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Book",18}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Book",18}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",18}]])//Timing

Length[plemb]

GraphData[{"Book",18},"PlanarEmbeddingCount"]

MinimalCrossing

GraphData[{"Book",18},{"RCN","CN"}]

GraphData[{"Book",18},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Book",18},"LocalCrossingNumber"]

GraphData[{"Book",18},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Book",18},"Circulant"]

GraphData[{"Book",18},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Book",18},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",18}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",18},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Book",18},"ComplementGraph","Name"]

Line graph

GraphData[{"Book",18},"Line"]

LineGraphQ[GraphData[{"Book",18}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Book",18}&]

RootGraph[GraphData[{"Book",18}]]

RecognizeGraph[%]

Halin

GraphData[{"Book",18},"Halin"]

GraphData[{"Book",18},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Book",18},"Rigid"]

GraphData[{"Book",18},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Book",18},"Flexible"]

GraphData[{"Book",18},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Book",18},"LCF"]

GraphData[{"Book",18},"HamiltonianCycleCount"]

GraphData[{"Book",18},"LCFSignature"]

GraphData[{"Book",18},"LCFNotations"]

GraphData[{"Book",18},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Book",18},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Book",18}],Debug->True]//Timing

GraphData[{"Book",18},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Book",18},"VertexList"],GraphData[{"Book",18},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Book",18},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Book",18}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Book",18}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Book",18},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Book",18}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Matchstick

GraphData[{"Book",18},"Matchstick"]

GraphData[{"Book",18},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Book",18},"Edges"]]

3D construction

g=BookGraph[{"Book",18}[[2]],GraphLayout->"3DEmbedding"]

3D All

GraphData[{"Book",18},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Book",18},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Book",18},"Polyhedral"]

GraphData[{"Book",18},"Graph",{"3D","Polyhedron"}]

{"Book", 19}

Names

GraphData[{"Book",19},"StandardName"]

GraphData[{"Book",19},"StandardNames"]

Primary

GraphData[{"Book",19}]//StyleGraphs[#,ImageSize->Small]&

Construction

gs=Table[BookGraph[{"Book",19}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

GraphData[{"Book",19},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Book",19},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Book",19}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",19},"VertexList"],GraphData[{"Book",19},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

Degenerate

GraphData[{"Book",19},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Book",19},"Graph","Degenerate"]

Configuration

GraphData[{"Book",19},"Configuration"]

GraphData[{"Book",19},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Book",19},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Book",19},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Book",19},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Book",19},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Book",19},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Book",19},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Book",19},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Book",19},"Hamiltonian"]

GraphData[{"Book",19},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Book",19}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",19}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"Book",19},"Planar"]

GraphData[{"Book",19},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Book",19}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Book",19}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",19}]])//Timing

Length[plemb]

GraphData[{"Book",19},"PlanarEmbeddingCount"]

MinimalCrossing

GraphData[{"Book",19},{"RCN","CN"}]

GraphData[{"Book",19},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Book",19},"LocalCrossingNumber"]

GraphData[{"Book",19},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Book",19},"Circulant"]

GraphData[{"Book",19},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Book",19},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",19}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",19},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Book",19},"ComplementGraph","Name"]

Line graph

GraphData[{"Book",19},"Line"]

LineGraphQ[GraphData[{"Book",19}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Book",19}&]

RootGraph[GraphData[{"Book",19}]]

RecognizeGraph[%]

Halin

GraphData[{"Book",19},"Halin"]

GraphData[{"Book",19},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Book",19},"Rigid"]

GraphData[{"Book",19},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Book",19},"Flexible"]

GraphData[{"Book",19},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Book",19},"LCF"]

GraphData[{"Book",19},"HamiltonianCycleCount"]

GraphData[{"Book",19},"LCFSignature"]

GraphData[{"Book",19},"LCFNotations"]

GraphData[{"Book",19},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Book",19},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Book",19}],Debug->True]//Timing

GraphData[{"Book",19},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Book",19},"VertexList"],GraphData[{"Book",19},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Book",19},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Book",19}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Book",19}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Book",19},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Book",19}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Matchstick

GraphData[{"Book",19},"Matchstick"]

GraphData[{"Book",19},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Book",19},"Edges"]]

3D construction

g=BookGraph[{"Book",19}[[2]],GraphLayout->"3DEmbedding"]

3D All

GraphData[{"Book",19},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Book",19},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Book",19},"Polyhedral"]

GraphData[{"Book",19},"Graph",{"3D","Polyhedron"}]

{"Book", 20}

Names

GraphData[{"Book",20},"StandardName"]

GraphData[{"Book",20},"StandardNames"]

Primary

GraphData[{"Book",20}]//StyleGraphs[#,ImageSize->Small]&

Construction

gs=Table[BookGraph[{"Book",20}[[2]],GraphLayout->layout],{layout,{"RectangularEmbedding","SquareInteriorEmbedding","HexagonEmbedding","CircularEmbedding","StarEmbedding","UnitDistanceEmbedding"}}]//StyleGraphs

All

GraphData[{"Book",20},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Book",20},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Book",20}]]

Default embedding

GraphPlot[Graph[GraphData[{"Book",20},"VertexList"],GraphData[{"Book",20},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

Degenerate

GraphData[{"Book",20},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Book",20},"Graph","Degenerate"]

Configuration

GraphData[{"Book",20},"Configuration"]

GraphData[{"Book",20},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Book",20},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"Book",20},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Book",20},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Book",20},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Book",20},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Book",20},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Book",20},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Book",20},"Hamiltonian"]

GraphData[{"Book",20},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Book",20}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Book",20}],#]&/@hc

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"Book",20},"Planar"]

GraphData[{"Book",20},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Book",20}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Book",20}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Book",20}]])//Timing

Length[plemb]

GraphData[{"Book",20},"PlanarEmbeddingCount"]

MinimalCrossing

GraphData[{"Book",20},{"RCN","CN"}]

GraphData[{"Book",20},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Book",20},"LocalCrossingNumber"]

GraphData[{"Book",20},"Graph","MinimalLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Book",20},"Circulant"]

GraphData[{"Book",20},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Book",20},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Book",20}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Book",20},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Book",20},"ComplementGraph","Name"]

Line graph

GraphData[{"Book",20},"Line"]

LineGraphQ[GraphData[{"Book",20}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Book",20}&]

RootGraph[GraphData[{"Book",20}]]

RecognizeGraph[%]

Halin

GraphData[{"Book",20},"Halin"]

GraphData[{"Book",20},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Book",20},"Rigid"]

GraphData[{"Book",20},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Book",20},"Flexible"]

GraphData[{"Book",20},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Book",20},"LCF"]

GraphData[{"Book",20},"HamiltonianCycleCount"]

GraphData[{"Book",20},"LCFSignature"]

GraphData[{"Book",20},"LCFNotations"]

GraphData[{"Book",20},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Book",20},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Book",20}],Debug->True]//Timing

GraphData[{"Book",20},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Book",20},"VertexList"],GraphData[{"Book",20},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Book",20},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Book",20}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Book",20}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Book",20},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Book",20}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Matchstick

GraphData[{"Book",20},"Matchstick"]

GraphData[{"Book",20},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Book",20},"Edges"]]

3D construction

g=BookGraph[{"Book",20}[[2]],GraphLayout->"3DEmbedding"]

3D All

GraphData[{"Book",20},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Book",20},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Book",20},"Polyhedral"]

GraphData[{"Book",20},"Graph",{"3D","Polyhedron"}]

Isomorphism

ToEntity/@BookGraph/@Range[20]

Grid[DeleteCases[Table[{n,RecognizeGraph[BookGraph[n]]},{n,20}],{_,{"Book",_}}],Dividers->All]

Grid[{#,GraphData[#,"StandardNames"]}&/@{"SquareGraph","DominoGraph",{"Book",3},{"Book",4}},Dividers->All,Alignment->Left]

Grid[{#,GraphData[#,"Names"]}&/@{"SquareGraph","DominoGraph",{"Book",3},{"Book",4}},Dividers->All,Alignment->Left]

Properties

Acyclic

seq=Table[GraphData[{"Book",n},"Acyclic"],{n,20}]

AdjacencyMatrixCount

seq=Table[GraphData[{"Book",n},"AdjacencyMatrixCount"],{n,20}]

FullSimplify[(((2(n+1))!)/(2n!))]

Table[(((2(n+1))!)/(Piecewise[{{8,n==1}},2n!])),{n,20}]

Arboricity

Table[GraphData[{"Book",n},"Arboricity"],{n,20}]

ArcTransitive

seq=Table[GraphData[{"Book",n},"ArcTransitive"],{n,20}]

ArcTransitivity

seq=Table[GraphData[{"Book",n},"ArcTransitivity"],{n,20}]

AutomorphismCount

seq=Table[GraphData[{"Book",n},"AutomorphismCount"],{n,20}]

FindSequenceFunction[Rest@seq,n-1]//FunctionExpand

BalabanIndex

seq=Table[GraphData[{"Book",n},"BalabanIndex"],{n,4}]//FullSimplify

Bandwidth

seq=Table[GraphData[{"Book",n},"Bandwidth"],{n,20}]

BridgeCount

seq=Table[GraphData[{"Book",n},"BridgeCount"],{n,20}]

BurningNumber

seq=Table[GraphData[{"Book",n},"BurningNumber"],{n,20}]

CharacteristicPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"CharacteristicPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Chordal

seq=Table[GraphData[{"Book",n},"Chordal"],{n,20}]

ChordCount

seq=Table[GraphData[{"Book",n},"ChordCount"],{n,20}]

Chordless

seq=Table[GraphData[{"Book",n},"Chordless"],{n,20}]

ChordlessCycleCount

seq=Table[GraphData[{"Book",n},"ChordlessCycleCount"],{n,20}]

Chords

seq=Table[GraphData[{"Book",n},"Chords"],{n,20}]

ChromaticallyUnique

seq=Table[GraphData[{"Book",n},"ChromaticallyUnique"],{n,20}]

GraphData[{"ChromaticallyUnique","Book"}]

ChromaticInvariant

seq=Table[GraphData[{"Book",n},"ChromaticInvariant"],{n,20}]

ChromaticNumber

seq=Table[GraphData[{"Book",n},"ChromaticNumber"],{n,20}]

ChromaticPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"ChromaticPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Circumference

seq=Table[GraphData[{"Book",n},"Circumference"],{n,20}]

Classes

Intersection@@(GraphData[#,"Classes"]&/@GraphData["Book"])

CliqueCount

seq=Table[GraphData[{"Book",n},"CliqueCount"],{n,20}]

FindSequenceFunction[seq,n]

CliqueCoveringNumber

seq=Table[GraphData[{"Book",n},"CliqueCoveringNumber"],{n,20}]

FindSequenceFunction[seq,n]

CliqueNumber

seq=Table[GraphData[{"Book",n},"CliqueNumber"],{n,20}]

CliquePolynomial

(poly=Factor[Table[GraphData[{"Book",n},"CliquePolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

CochromaticGraphNames

Table[GraphData[{"Book",n},"CochromaticGraphNames"],{n,20}]//Column

Select[GraphData["Book"],GraphData[#,"ChromaticallyUnique"]=!=False&]

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"Book",n},"ComplementOddChordlessCycleCount"],{n,20}]

ConnectedComponentCount

seq=Table[GraphData[{"Book",n},"ConnectedComponentCount"],{n,20}]

ConnectedDominatingSetCount

A242985(n) for n > 1

seq=Table[GraphData[{"Book",n},"ConnectedDominatingSetCount"],{n,20}]

FindLinearRecurrence[DeleteCases[seq,_Missing]]

FindLinearRecurrence[DeleteCases[Drop[seq,1],_Missing]]

LinearRecurrence[{6,-8},{8,24},{0,20}]

seq=Table[(4^n)+(2^(n+1)),{n,0,20}]

gf=x FindGeneratingFunction[seq,x]//Factor

CoefficientList[Series[-(((-3+10 x))/((-1+2 x) (-1+4 x))),{x,0,20}],x]

FindSequenceFunction[DeleteCases[Drop[seq,1],_Missing],n-1]//FullSimplify

Table[Piecewise[{{9,n==1}},(2^(1+n))+(4^n)],{n,20}]

FullSimplify[If[n==1,1,0]+(((1+x))^n) (2 (x^(n-1))+(((1+x))^n))/.x->1]

ConnectedDominationNumber

seq=Table[GraphData[{"Book",n},"ConnectedDominationNumber"],{n,20}]

ConnectedDominationPolynomial

related to A213669

(poly=Factor/@Table[GraphData[{"Book",n},"ConnectedDominationPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing[poly]]

CoefficientList[Take[DeleteMissing[poly],6],x]

p=.

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[Piecewise[{{4 (x^2)+4 (x^3)+(x^4),n==1}},x (x (((1+x))^(2 n))+2 (((x (1+x)))^n))],{n,2,10}]

FullSimplify[poly2-poly]

CoefficientList[Take[poly2,5],x]

CoefficientList[Table[Piecewise[{{4 +4 x+(x^2),n==1}},(((1+x))^n) (2 (x^(n-1))+(((1+x))^n))],{n,5}],x]

CoefficientList[Table[If[n==1,1,0]+(((1+x))^n) (2 (x^(n-1))+(((1+x))^n)),{n,5}],x]

(((1+x))^n) (2 (x^(n-1))+(((1+x))^n))/.n->1//Expand

ConnectedInducedSubgraphCount

A290720

seq=Table[GraphData[{"Book",n},"ConnectedInducedSubgraphCount"],{n,20}]

FindLinearRecurrence[seq]

seq=LinearRecurrence[{9,-27,31,-12},{13,40,127,430},{0,40}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]//FullSimplify

x (x (((1+x))^(2 n))+n (2+x)+2 (((1+x+(x^2)))^n))/.x->1//FullSimplify

Table[2 (3^n)+(4^n)+3 n,{n,0,20}]

gf=FindGeneratingFunction[seq,x]

Series[((3-14 x+4 (x^2)+25 (x^3))/((((-1+x))^2) (1-7 x+12 (x^2)))),{x,0,20}]

CoefficientList[Series[((3-14 x+4 (x^2)+25 (x^3))/((((-1+x))^2) (1-7 x+12 (x^2)))),{x,0,20}],x]

ConnectedInducedSubgraphPolynomial

(poly=DeleteCases[Factor@Table[GraphData[{"Book",n},"ConnectedInducedSubgraphPolynomial"][x],{n,k0=1,kmax=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 (x (((1+x))^(2 n))+n (2+x)+2 (((1+x+(x^2)))^n)),{n,Length[poly]}]

FullSimplify[poly2-poly]

CrossingNumber

seq=Table[GraphData[{"Book",n},"CrossingNumber"],{n,20}]

CycleCount

seq=Table[GraphData[{"Book",n},"CycleCount"],{n,20}]

FindSequenceFunction[Rest@seq,n-1]//Factor

CyclePolynomial

(poly=Factor[Table[GraphData[{"Book",n},"CyclePolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Cyclic

Table[GraphData[{"Book",n},"Cyclic"],{n,20}]

CyclomaticNumber

seq=Table[GraphData[{"Book",n},"CyclomaticNumber"],{n,20}]

FindSequenceFunction[seq,n]

DetourIndex

seq=Table[GraphData[{"Book",n},"DetourIndex"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindSequenceFunction[seq,x]

DetourMatrix

MatrixForm/@Table[GraphData[{"Book",n},"DetourMatrix"],{n,20}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,20}]

DetourPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"DetourPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Diameter

seq=Table[GraphData[{"Book",n},"Diameter"],{n,20}]

DistanceMatrix

MatrixForm/@Table[GraphData[{"Book",n},"DistanceMatrix"],{n,20}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,20}]

DistancePolynomial

(poly=Factor[Table[GraphData[{"Book",n},"DistancePolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

DistinguishingNumber

seq=Table[GraphData[{"Book",n},"DistinguishingNumber"],{n,20}]

DomaticNumber

seq=Table[GraphData[{"Book",n},"DomaticNumber"],{n,20}]

DominatingSetCount

A288795

seq=Table[GraphData[{"Book",n},"DominatingSetCount"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

seq=Table[4^n+3^(n+1)-2,{n,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{8,-19,12},{11,41,143},20]

gf=x FindGeneratingFunction[seq,x]//Factor

ToString[gf,InputForm]

CoefficientList[Series[-(((11-47 x+24 (x^2)))/((-1+x) (-1+3 x) (-1+4 x))),{x,0,20}],x]

DominationNumber

seq=Table[GraphData[{"Book",n},"DominationNumber"],{n,10}]

DominationPolynomial

(poly=Factor/@Table[GraphData[{"Book",n},"DominationPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[Rest@DeleteMissing[poly]]

CoefficientList[Take[DeleteMissing[poly],6],x]

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[Piecewise[{{4 (x^2)+4 (x^3)+(x^4),n==1}},x (((1+x))^n) (2 (x^n)+x (((1+x))^n))],{n,20}]

FullSimplify[Take[poly2-poly,Length[DeleteMissing[poly]]]]

CoefficientList[Take[poly2,5],x]

CoefficientList[Table[Piecewise[{{4 +4 x+(x^2),n==1}},(((1+x))^n) (2 (x^(n-1))+(((1+x))^n))],{n,5}],x]

?KroneckerDelta

CoefficientList[Table[If[n==1,1,0]+(((1+x))^n) (2 (x^(n-1))+(((1+x))^n)),{n,5}],x]

(((1+x))^n) (2 (x^(n-1))+(((1+x))^n))/.n->1//Expand

EdgeChromaticNumber

seq=Table[GraphData[{"Book",n},"EdgeChromaticNumber"],{n,20}]

FindSequenceFunction[seq,n]

EdgeConnectivity

Table[GraphData[{"Book",n},"EdgeConnectivity"],{n,20}]

EdgeCount

seq=Table[GraphData[{"Book",n},"EdgeCount"],{n,20}]

FindSequenceFunction[seq,n]

EdgeCoverCount

seq=Table[GraphData[{"Book",n},"EdgeCoverCount"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

EdgeCoverNumber

seq=Table[GraphData[{"Book",n},"EdgeCoverNumber"],{n,20}]

FindSequenceFunction[seq,n]

EdgeCoverPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"EdgeCoverPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

EulerianCycleCount

seq=Table[GraphData[{"Book",n},"EulerianCycleCount"],{n,20}]

FaceCount

seq=Table[GraphData[{"Book",n},"FaceCount"],{n,20}]

FlowPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"FlowPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

FractionalChromaticNumber

seq=Table[GraphData[{"Book",n},"FractionalChromaticNumber"],{n,20}]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"Book",n},"FractionalEdgeChromaticNumber"],{n,20}]

FindSequenceFunction[seq,n]

Girth

seq=Table[GraphData[{"Book",n},"Girth"],{n,20}]

Gonality

seq=Table[GraphData[{"Book",n},"Gonality"],{n,20}]

HamiltonConnected

seq=Table[GraphData[{"Book",n},"HamiltonConnected"],{n,20}]

HamiltonDecompositionCount

seq=Table[GraphData[{"Book",n},"HamiltonDecompositionCount"],{n,20}]

Hamiltonian

Table[GraphData[{"Book",n},"Hamiltonian"],{n,20}]

HamiltonianCycleCount

seq=Table[GraphData[{"Book",n},"HamiltonianCycleCount"],{n,20}]

HamiltonianNumber

Probably 2(n+1)

seq=Table[GraphData[{"Book",n},"HamiltonianNumber"],{n,20}]

HamiltonianPathCount

seq=Table[GraphData[{"Book",n},"HamiltonianPathCount"],{n,20}]

HamiltonianWalkCount

seq=Table[GraphData[{"Book",n},"HamiltonianWalkCount"],{n,20}]

HararyIndex

seq=Table[GraphData[{"Book",n},"HararyIndex"],{n,20}]

FindSequenceFunction[seq,n]

HexagonCount

seq=Table[GraphData[{"Book",n},"HexagonCount"],{n,20}]

FindSequenceFunction[seq,n]

IdiosyncraticPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"IdiosyncraticPolynomial"][x,y],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

IndependenceNumber

seq=Table[GraphData[{"Book",n},"IndependenceNumber"],{n,20}]

FindSequenceFunction[seq,n]

IndependencePolynomial

(poly=Factor[Table[GraphData[{"Book",n},"IndependencePolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

IndependenceRatio

seq=Table[GraphData[{"Book",n},"IndependenceRatio"],{n,20}]

IndependentEdgeSetCount

A084264

seq=Table[GraphData[{"Book",n},"IndependentEdgeSetCount"],{n,20}]

FindSequenceFunction[seq,n-1]//FullSimplify//Factor

Table[(2^(n-3)) (4+3 n+(n^2)),{n,0,20}]

seq=Table[If[n==0,1,(2^(n-3))((n^2)+3n+4)],{n,0,20}]

FindLinearRecurrence[seq]

Join[{1},LinearRecurrence[{6,-12,8},{2,7,22},20]]

FindGeneratingFunction[seq,x]

CoefficientList[Series[((-1+4 x-7 (x^2)+4 (x^3))/(((-1+2 x))^3)),{x,0,20}],x]

IndependentVertexSetCount

A085279

seq=Table[GraphData[{"Book",n},"IndependentVertexSetCount"],{n,20}]

FindLinearRecurrence[seq]

Join[{1},LinearRecurrence[{5,-6},{3,7},20]]

FindSequenceFunction[seq,n]

Join[{1},Table[(2^n)+(3^(n-1)),{n,20}]]

IntersectionNumber

seq=Table[GraphData[{"Book",n},"IntersectionNumber"],{n,20}]

IrredundantSetCount

A290651

seq=Table[GraphData[{"Book",n},"IrredundantSetCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//FullSimplify

Table[5-(2^(1+n))+(3^(1+n))+n,{n,-1,40}]

seq=Table[5-(2^(n-1))+(3^(n-1))+n-2,{n,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{7,-17,17,-6},{4,6,11,26},20]

gf=x FindGeneratingFunction[seq,x]

Series[gf,{x,0,10}]

CoefficientList[Series[((4-22 x+37 (x^2)-17 (x^3))/((((-1+x))^2) (1-5 x+6 (x^2)))),{x,0,20}],x]

KirchhoffIndex

seq=Table[GraphData[{"Book",n},"KirchhoffIndex"],{n,20}]

FindSequenceFunction[seq,n]//Factor

KirchhoffSumIndex

seq=Table[GraphData[{"Book",n},"KirchhoffSumIndex"],{n,20}]

FindSequenceFunction[seq,n]//Factor

LaplacianMatrix

MatrixForm/@Table[GraphData[{"Book",n},"LaplacianMatrix"],{n,20}]

LaplacianPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"LaplacianPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

LeafCount

seq=Table[GraphData[{"Book",n},"LeafCount"],{n,20}]

LongestCycleCount

Same as |HC|

seq=Table[GraphData[{"Book",n},"LongestCycleCount"],{n,20}]

LovaszNumber

seq=Table[GraphData[{"Book",n},"LovaszNumber"],{n,20}]

MatchingGeneratingPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"MatchingGeneratingPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

MatchingNumber

seq=Table[GraphData[{"Book",n},"MatchingNumber"],{n,20}]

FindSequenceFunction[seq,n]

MatchingPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"MatchingPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

MaximalCliqueCount

seq=Table[GraphData[{"Book",n},"MaximalCliqueCount"],{n,20}]

FindSequenceFunction[seq,n]

MaximalIndependentEdgeSetCount

seq=Table[GraphData[{"Book",n},"MaximalIndependentEdgeSetCount"],{n,20}]

FindSequenceFunction[seq,n]

MaximalIndependentVertexSetCount

seq=Table[GraphData[{"Book",n},"MaximalIndependentVertexSetCount"],{n,20}]

FindSequenceFunction[seq,n]

MaximalIrredundantSetCount

A291064

seq=Table[GraphData[{"Book",n},"MaximalIrredundantSetCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

FindLinearRecurrence[DeleteMissing@seq]

FindLinearRecurrence[Rest@DeleteMissing@seq]

seq=LinearRecurrence[{6,-13,12,-4},{4,9,26,71,180},40]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((4-15 x+24 (x^2)-16 (x^3))/(((1-3 x+2 (x^2)))^2)),{x,0,20}],x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

Table[(2^n)(n+1)-3(n-1),{n,20}]

MaximumLeafNumber

seq=Table[GraphData[{"Book",n},"MaximumLeafNumber"],{n,20}]

MaximumVertexDegree

seq=Table[GraphData[{"Book",n},"MaximumVertexDegree"],{n,20}]

MeanDistance

seq=Table[GraphData[{"Book",n},"MeanDistance"],{n,20}]

FindSequenceFunction[seq,n]

MinimalDominatingSetCount

seq=Table[GraphData[{"Book",n},"MinimalDominatingSetCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//Factor

FindSequenceFunction[Rest@DeleteMissing@seq,n-1]//Factor

MinimalDominatingSetSignature

seq=Table[GraphData[{"Book",n},"MinimalDominatingSetSignature"],{n,20}]//Column

FindSequenceFunction[{6,14,30,62,126},n-2]//FullSimplify

MinimalEdgeCoverCount

A290699

seq=Table[GraphData[{"Book",n},"MinimalEdgeCoverCount"],{n,20}]

Table[GraphData[{"Book",n},"EdgeCoverCount"],{n,20}]

FindLinearRecurrence[DeleteMissing@seq]

FindSequenceFunction[DeleteMissing@seq,n]//Factor

seq=Table[(2^n)-n+(n^2),{n,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{5,-9,7,-2},{2,6,14,28},20]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((2 (-1+2 x-(x^2)+(x^3)))/((((-1+x))^3) (-1+2 x))),{x,0,20}],x]

MinimumCliqueCoveringCount

seq=Table[GraphData[{"Book",n},"MinimumCliqueCoveringCount"],{n,20}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"Book",n},"MinimumConnectedDominatingSetCount"],{n,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"Book",n},"MinimumDistinguishingLabelingCount"],{n,20}]

MinimumDominatingSetCount

seq=Table[GraphData[{"Book",n},"MinimumDominatingSetCount"],{n,20}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"Book",n},"MinimumEdgeCoverCount"],{n,20}]

MinimumVertexDegree

seq=Table[GraphData[{"Path",n},"MinimumVertexDegree"],{n,20}]

MolecularTopologicalIndex

seq=Table[GraphData[{"Book",n},"MolecularTopologicalIndex"],{n,20}]

FindSequenceFunction[seq,n]

FindGeneratingFunction[seq,x]//Factor

Nonhamiltonian

Table[GraphData[{"Book",n},"Nonhamiltonian"],{n,20}]

NormalizedLaplacianMatrix

MatrixForm/@Table[GraphData[{"Book",n},"NormalizedLaplacianMatrix"],{n,5}]

OddChordlessCycleCount

seq=Table[GraphData[{"Book",n},"OddChordlessCycleCount"],{n,20}]

PathCount

seq=Table[GraphData[{"Book",n},"PathCount"],{n,20}]

FindLinearRecurrence[DeleteMissing@seq]

FindSequenceFunction[DeleteMissing@seq,n]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]//Factor

PathPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"PathPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

p=.

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

PentagonCount

seq=Table[GraphData[{"Book",n},"PentagonCount"],{n,20}]

Perfect

Table[GraphData[{"Book",n},"Perfect"],{n,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"Book",n},"ProjectivePlaneCrossingNumber"],{n,20}]

Radius

seq=Table[GraphData[{"Book",n},"Radius"],{n,20}]

RankPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"RankPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"Book",n},"RectilinearCrossingNumber"],{n,20}]

ReliabilityPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"ReliabilityPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

SigmaPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"SigmaPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

SpanningTreeCount

A006234

seq=Table[GraphData[{"Book",n},"SpanningTreeCount"],{n,20}]

FindSequenceFunction[seq,n]

FindGeneratingFunction[Take[seq,7],x]

SquareCount

seq=Table[GraphData[{"Book",n},"SquareCount"],{n,20}]

StabilityIndex

seq=Table[GraphData[{"Book",n},"StabilityIndex"],{n,20}]

FindSequenceFunction[seq,n]

TopologicalIndex

seq=Table[GraphData[{"Book",n},"TopologicalIndex"],{n,20}]

FindSequenceFunction[seq,n]

ToroidalCrossingNumber

seq=Table[GraphData[{"Book",n},"ToroidalCrossingNumber"],{n,20}]

Traceable

Table[GraphData[{"Book",n},"Traceable"],{n,20}]

TriangleCount

seq=Table[GraphData[{"Book",n},"TriangleCount"],{n,20}]

TuttePolynomial

(poly=Factor[Table[GraphData[{"Book",n},"TuttePolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Untraceable

Table[GraphData[{"Book",n},"Untraceable"],{n,20}]

VertexConnectivity

Table[GraphData[{"Book",n},"VertexConnectivity"],{n,20}]

VertexCount

seq=Table[GraphData[{"Book",n},"VertexCount"],{n,20}]

FindSequenceFunction[seq,n]

VertexCoverNumber

vertex cover number == vertex count - independence number

seq=Table[GraphData[{"Book",n},"VertexCoverNumber"],{n,20}]

FindSequenceFunction[seq,n]

VertexCoverPolynomial

(poly=Factor[Table[GraphData[{"Book",n},"VertexCoverPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

VertexDegrees

seq=Table[GraphData[{"Book",n},"VertexDegrees"],{n,20}]

VertexTransitive

Table[GraphData[{"Book",n},"VertexTransitive"],{n,20}]

WienerIndex

seq=Table[GraphData[{"Book",n},"WienerIndex"],{n,20}]

FindSequenceFunction[seq,n]

WienerSumIndex

seq=Table[GraphData[{"Book",n},"WienerSumIndex"],{n,20}]

FindSequenceFunction[seq,n]//Factor

GraphData

GraphClassString

GraphClassString[GraphData["Book"]]

GraphDataString

Do[Print[GraphDataString[BookGraph[m],
"Name"->ToString[m]<>"-book graph",
"StandardName"->{"Book",m},
"Classes"->{"Book"},
"NotationRules"->{"Book"->m},
"Information"->"BookGraph",
TimeConstraint->120
]],{m,3,20}]