Wheel Graph

Author

Eric W. Weisstein
October 21, 2024

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

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

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

Figure

GraphicsGrid[Table[
MyWheelGraph[
n,
GraphLayout->layout,
PlotLabel->If[layout==="RadialEmbedding",Subscript[Style["W",Italic],n],None],
BaseStyle->Directive[14,FontFamily->"Times"]
]/.{g_Graph:>StyleGraphs[g],_->NullGraph},
{layout,{"RadialEmbedding","TriangularEmbedding","CircularEmbedding","StarEmbedding"}},
{n,4,8}
],Dividers->All]

Polygram

Import["https://mathworld.wolfram.com/images/eps-svg/Polygram_800.svg"]

GraphData

GraphicsGrid[Partition[Show[GraphData[{"Wheel",#}]/.g_Graph:>SetProperty[g,{VertexSize->If[#==1,.017,{"Scaled",.07}],VertexStyle->Red,EdgeStyle->Black}],PlotLabel->Style[Subscript[W,#],Directive[Black,FontFamily->"Times"]]]&/@Range[4,12],4],ImageSize->400,Dividers->All,Alignment->Top]

Built-it

GraphicsGrid[Partition[Table[Show[WheelGraph[n,VertexSize->If[n==1,.017,{"Scaled",.07}],VertexStyle->Red,EdgeStyle->Black],PlotLabel->Style[Subscript[W,n],Directive[Black,FontFamily->"Times"]]],{n,4,11}],UpTo[4]],ImageSize->400,Dividers->All,Alignment->Top]

Graphs.m package "CircularEmbedding"

GraphicsGrid[Partition[Table[Show[MyWheelGraph[n,GraphLayout->"CircularEmbedding",VertexSize->If[n==1,.017,{"Scaled",.07}],VertexStyle->Red,EdgeStyle->Black],PlotLabel->Style[Subscript[W,n],Directive[Black,FontFamily->"Times"]]],{n,4,11}],UpTo[4]],ImageSize->400,Dividers->All,Alignment->Top]

Graphs.m package "TriangleEmbedding"

GraphicsGrid[Partition[Table[Show[MyWheelGraph[n,GraphLayout->"TriangleEmbedding",VertexSize->If[n==1,.017,{"Scaled",.07}],VertexStyle->Red,EdgeStyle->Black],PlotLabel->Style[Subscript[W,n],Directive[Black,FontFamily->"Times"]]],{n,4,11}],UpTo[4]],ImageSize->400,Dividers->All,Alignment->Top]

Special cases

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

Skeleton of pyramid

PyramidalGraphFromPolyhedron[n_]:=Module[{faces=Polyhedron[Pyramid[n]][[All,1]],v,e,vlist},
v=Union@@faces;
vlist=Range[Length[v]];
e=Union@@((Sort/@Partition[#,2,1,1])&/@(faces/.Thread[v->vlist]));
System`Graph[vlist,e,VertexCoordinates->v]
]

TextGrid[Table[{n,PyramidalGraphFromPolyhedron[n]//RecognizeGraph},{n,3,10}]]

Properties

Acyclic

Table[GraphData[{"Wheel",n},"Acyclic"],{n,4,20}]

AdjacencyMatrixCount

seq=Table[GraphData[{"Wheel",n},"AdjacencyMatrixCount"],{n,4,20}]

FindSequenceFunction[seq,n-3]

FindSequenceFunction[Rest@seq,n-4]//FunctionExpand

Table[Piecewise[{{1,n==4}},(1/2) n Gamma[n-1]],{n,4,20}]

Arboricity

Table[GraphData[{"Wheel",n},"Arboricity"],{n,4,20}]

ArcTransitive

Table[GraphData[{"Wheel",n},"ArcTransitive"],{n,4,20}]

ArcTransitivity

Table[GraphData[{"Wheel",n},"ArcTransitivity"],{n,4,20}]

AutomorphismCount

Table[GraphData[{"Wheel",n},"AutomorphismCount"],{n,4,20}]

BalabanIndex

Table[GraphData[{"Wheel",n},"BalabanIndex"],{n,4,20}]

FactorInteger[665]

Table[n+Sqrt[n],{n,4,20}]

Bandwidth

seq=Table[GraphData[{"Wheel",n},"Bandwidth"],{n,4,20}]

Table[Piecewise[{{3,n==4||n==5}},Floor[n/2]],{n,4,20}]

%==seq

BridgeCount

seq=Table[GraphData[{"Wheel",n},"BridgeCount"],{n,4,20}]

BurningNumber

seq=Table[GraphData[{"Wheel",n},"BurningNumber"],{n,4,20}]

ChordCount

seq=Table[GraphData[{"Wheel",n},"ChordCount"],{n,4,20}]

FindSequenceFunction[DeleteMissing@seq,n-3]//Simplify

ChordlessCycleCount

seq=Table[GraphData[{"Wheel",n},"ChordlessCycleCount"],{n,4,20}]

ChromaticInvariant

seq=Table[GraphData[{"Wheel",n},"ChromaticInvariant"],{n,4,20}]

ChromaticNumber

seq=Table[GraphData[{"Wheel",n},"ChromaticNumber"],{n,4,20}]

Circumference

seq=Table[GraphData[{"Wheel",n},"Circumference"],{n,4,20}]

Classes

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

CliqueCount

seq=Table[GraphData[{"Wheel",n},"CliqueCount"],{n,4,20}]

FindSequenceFunction[seq,n-3]

FindSequenceFunction[Rest@seq,n-4]//Factor

Table[Piecewise[{{16,n==4}},2(2n-1)],{n,4,20}]

%==seq

CliqueCoveringNumber

seq=Table[GraphData[{"Wheel",n},"CliqueCoveringNumber"],{n,4,20}]

Table[Piecewise[{{1,n==4}},Floor[n/2]],{n,4,20}]

%==seq

CliqueNumber

seq=Table[GraphData[{"Wheel",n},"CliqueNumber"],{n,4,20}]

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"Wheel",n},"ComplementOddChordlessCycleCount"],{n,4,20}]

ConnectedDominatingSetCount

A176691

seq=Table[GraphData[{"Wheel",n},"ConnectedDominatingSetCount"],{n,4,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n-3]//FullSimplify

gf=FindGeneratingFunction[Table[2^n+2 n+1,{n,0,60}],x]

CoefficientList[Series[((-2+3 x+(x^2))/((((-1+x))^2) (-1+2 x))),{x,0,20}],x]

ConnectedDominationNumber

seq=Table[GraphData[{"Wheel",n},"ConnectedDominationNumber"],{n,4,20}]

ConnectedDominationPolynomial

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

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

A020873

seq=Table[GraphData[{"Wheel",n},"ConnectedInducedSubgraphCount"],{n,4,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n-3]//FullSimplify

ConnectedInducedSubgraphPolynomial

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

FullSimplify[poly2-poly]

CrossingNumber

seq=Table[GraphData[{"Wheel",n},"CrossingNumber"],{n,4,20}]

CycleCount

seq=Table[GraphData[{"Wheel",n},"CycleCount"],{n,4,20}]

FindSequenceFunction[seq,n-3]//Factor

Cyclic

Table[GraphData[{"Wheel",n},"Cyclic"],{n,4,20}]

CyclomaticNumber

seq=Table[GraphData[{"Wheel",n},"CyclomaticNumber"],{n,4,20}]

DetourIndex

seq=Table[GraphData[{"Wheel",n},"DetourIndex"],{n,4,20}]

FindSequenceFunction[seq,n-3]//FullSimplify

Diameter

seq=Table[GraphData[{"Wheel",n},"Diameter"],{n,4,20}]

DistinguishingNumber

seq=Table[GraphData[{"Wheel",n},"DistinguishingNumber"],{n,4,20}]

DomaticNumber

System`WheelGraph[5,VertexLabels->"Name"]

seq=Table[GraphData[{"Wheel",n},"DomaticNumber"],{n,4,20}]

Table[Piecewise[{{4,Mod[n,3]==1}},3],{n,4,20}]

Table[DomaticNumber[g=System`WheelGraph[n],FindDominatingSet[g,Infinity,All]],{n,4,7}]

DominatingSetCount

A213661

seq=Table[GraphData[{"Wheel",n},"DominatingSetCount"],{n,4,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{3,-1,-1,-2},{15,27,53,103},20]

FindSequenceFunction[seq,n-3]

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

FindSequenceFunction[{4,3,7,15,27,53,103,199,387,753,1467,2863,5595,10949,21455,42095,82691,162625,320179,631031},n]

FullSimplify[%]

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

%==seq

DominationNumber

seq=Table[GraphData[{"Wheel",n},"DominationNumber"],{n,4,20}]

EdgeChromaticNumber

seq=Table[GraphData[{"Wheel",n},"EdgeChromaticNumber"],{n,4,20}]

EdgeConnectivity

Table[GraphData[{"Wheel",n},"EdgeConnectivity"],{n,4,20}]

EdgeCount

seq=Table[GraphData[{"Wheel",n},"M"],{n,4,20}]

FindSequenceFunction[seq,n-3]

EdgeCoverCount

seq=Table[GraphData[{"Wheel",n},"EdgeCoverCount"],{n,4,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{4,0,-5,-2},{0,2,10,41},20]

FindSequenceFunction[seq,n-3]//FullSimplify

Table[((2^(-1-n)) (2 (7+3 (Sqrt[5])) (((3+(Sqrt[17])))^(1+n))-4 (((1+(Sqrt[5])))^n) (2+(Sqrt[5])) (13+3 (Sqrt[17]))+(2 (((-1+(Sqrt[5])))^n) (11+5 (Sqrt[5])) (13+3 (Sqrt[17]))-(7+3 (Sqrt[5])) (((-3+(Sqrt[17])))^n) (45+11 (Sqrt[17]))) (E^(I n π))))/((7+3 (Sqrt[5])) (13+3 (Sqrt[17]))),{n,3}]//FullSimplify

FindSequenceFunction[seq2={0,2,10,41,154,562,2023,7240,25842,92129,328270,1169390,4165231,14835316,52837774,188186161,670237602,2387090906,8501757271,30279468752},n]//FullSimplify

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

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

-Table[2 (((1-(Sqrt[5])))^n) (1+(Sqrt[5]))-2 (-1+(Sqrt[5])) (((1+(Sqrt[5])))^n),{n,2,10}]//FullSimplify

gf=x FindGeneratingFunction[seq2,x]

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

Table[ (2 (((1-(Sqrt[5])))^n) (1+(Sqrt[5]))-2 (-1+(Sqrt[5])) (((1+(Sqrt[5])))^n)-(((3-(Sqrt[17])))^n) (3+(Sqrt[17]))+(-3+(Sqrt[17])) (((3+(Sqrt[17])))^n)),{n,10}]//FullSimplify

EdgeCoverNumber

seq=Table[GraphData[{"Wheel",n},"EdgeCoverNumber"],{n,4,20}]

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

EulerianCycleCount

seq=Table[GraphData[{"Wheel",n},"EulerianCycleCount"],{n,4,20}]

FaceCount

seq=Table[GraphData[{"Wheel",n},"FaceCount"],{n,4,20}]

FibonacciCube

Entity["Graph",{"Wheel",n}]["FibonacciCube"]

seq=Table[GraphData[{"Wheel",n},"FibonacciCube"],{n,4,20}]

FractionalChromaticNumber

seq=Table[GraphData[{"Wheel",n},"FractionalChromaticNumber"],{n,4,20}]

Factor[((3(n/2)-2)/((n/2)-1))]

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

%==seq

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"Wheel",n},"FractionalEdgeChromaticNumber"],{n,4,20}]

Girth

seq=Table[GraphData[{"Wheel",n},"Girth"],{n,4,20}]

Gonality

seq=Table[GraphData[{"Wheel",n},"Gonality"],{n,4,20}]

HamiltonConnected

seq=Table[GraphData[{"Wheel",n},"HamiltonConnected"],{n,4,20}]

HamiltonDecompositionCount

seq=Table[GraphData[{"Wheel",n},"HamiltonDecompositionCount"],{n,4,20}]

Hamiltonian

Table[GraphData[{"Wheel",n},"Hamiltonian"],{n,4,20}]

HamiltonianCycleCount

seq=Table[GraphData[{"Wheel",n},"HamiltonianCycleCount"],{n,4,20}]

HamiltonianNumber

seq=Table[GraphData[{"Wheel",n},"HamiltonianNumber"],{n,4,20}]

HamiltonianPathCount

seq=Table[GraphData[{"Wheel",n},"HamiltonianPathCount"],{n,4,20}]

FindSequenceFunction[seq,n-3]//Factor

4 Binomial[n-1,2]

HamiltonianWalkCount

seq=Table[GraphData[{"Wheel",n},"HamiltonianWalkCount"],{n,4,20}]

HararyIndex

seq=Table[GraphData[{"Wheel",n},"HararyIndex"],{n,4,20}]

FindSequenceFunction[seq,n-3]//Factor

HexagonCount

seq=Table[GraphData[{"Wheel",n},"HexagonCount"],{n,4,20}]

IndependenceNumber

seq=Table[GraphData[{"Wheel",n},"IndependenceNumber"],{n,4,20}]

Table[Ceiling[n/2]-1,{n,4,20}]

IndependenceRatio

seq=Table[GraphData[{"Wheel",n},"IndependenceRatio"],{n,4,20}]

FindSequenceFunction[seq,n-3]//FullSimplify

IndependentEdgeSetCount

A061705(n-1)

seq=Table[GraphData[{"Wheel",n},"IndependentEdgeSetCount"],{n,4,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-3]//FullSimplify

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

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

Table[((((1-(Sqrt[5])))^n) (5-(Sqrt[5]) n)+(((1+(Sqrt[5])))^n) (5+(Sqrt[5]) n)),{n,4,20}]//FullSimplify

Table[n Fibonacci[n-1]+2Fibonacci[n-2],{n,4,20}]

Table[(n-1) Fibonacci[n-1]+LucasL[n-1],{n,4,20}]

%==seq

Table[n Fibonacci[n]+LucasL[n],{n,20}]

IndependentVertexSetCount

A001612

seq=Table[GraphData[{"Wheel",n},"IndependentVertexSetCount"],{n,4,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{2,0,-1},{3,2,4},20]

FindSequenceFunction[seq,n-3]//FullSimplify

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

FindSequenceFunction[{3,2,4,5,8,12,19,30,48,77,124,200,323,522,844,1365,2208,3572,5779,9350},n]

Table[Fibonacci[n]+Fibonacci[n-2]+1,{n,4,20}]

seq=Table[Fibonacci[n]+Fibonacci[n-2]+1,{n,20}]

FindGeneratingFunction[seq,x]

CoefficientList[Series[((3-4 x)/(1-2 x+(x^3))),{x,0,20}],x]

IntersectionNumber

seq=Table[GraphData[{"Wheel",n},"IntersectionNumber"],{n,4,20}]

IrredundantSetCount

A290494

seq=Table[GraphData[{"Wheel",n},"IrredundantSetCount"],{n,4,20}]

(seq=Table[Length[IrredundantSets[WheelGraph[n]]],{n,4,17}])//Timing

FindLinearRecurrence[seq]

LinearRecurrence[{2,0,-1,1,-1,-1,1},{5,12,17,25,44,76,131},20]

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

CoefficientList[Series[gf/x,{x,0,20}],x]

CoefficientList[Series[((-5-2 x+7 (x^2)+4 (x^3)-(x^4)+2 (x^5)-4 (x^6))/(-1+2 x-(x^3)+(x^4)-(x^5)-(x^6)+(x^7))),{x,0,20}],x]

Series[gf,{x,0,20}]

res=Refine[SeriesCoefficient[gf,{x,0,n}],n>5]-1

terms=List@@res;

terms[[1]]

N[terms/.n->0]//Chop

t1=terms[[1]]/.n->0

r1=RootApproximant[N[t1,50],8]

N[t1-r1,1000]

terms[[All,1]]

RootApproximant[N[terms/.n->0,50],8]

1+Table[Sum[((Root[1-((#1)^2)-((#1)^4)-((#1)^5)+((#1)^6)&,k])^n)Root[1-11 #1+23 ((#1)^2)-24 ((#1)^3)+15 ((#1)^4)-6 ((#1)^5)+((#1)^6)&,{2,1,3,4,5,6}[[k]]],{k,6}],{n,6,10}]//N//Chop

f1=1-((#1)^2)-((#1)^4)-((#1)^5)+((#1)^6)&;
f2=1-11 #1+23 ((#1)^2)-24 ((#1)^3)+15 ((#1)^4)-6 ((#1)^5)+((#1)^6)&;

an=ToNumberField[Root[f2,{2,1,3,4,5,6}[[#]]],Root[f1,#]]&/@Range[6]

Equal@@Last/@an

1+RootSum[1-((#1)^2)-((#1)^4)-((#1)^5)+((#1)^6)&,((#)^n)(2+#+((#)^3)-((#)^4))&]

seq=Table[1-RootSum[1-((#1)^2)-((#1)^4)-((#1)^5)+((#1)^6)&,-2 ((#1)^(n+3))-((#1)^(n+4))-((#1)^(n+6))+((#1)^(n+7))&],{n,4,30}]

seq

KirchhoffIndex

seq=Table[GraphData[{"Wheel",n},"KirchhoffIndex"],{n,4,20}]

FindSequenceFunction[seq,n-3]

(x^3)FindGeneratingFunction[seq,x]

KirchhoffSumIndex

seq=Table[GraphData[{"Wheel",n},"KirchhoffSumIndex"],{n,4,20}]

FindSequenceFunction[seq,n-3]

(x^3)FindGeneratingFunction[seq,x]

LeafCount

seq=Table[GraphData[{"Wheel",n},"LeafCount"],{n,4,20}]

LongestCycleCount

seq=Table[GraphData[{"Wheel",n},"LongestCycleCount"],{n,4,20}]

LovaszNumber

seq=Table[GraphData[{"Wheel",n},"LovaszNumber"],{n,4,20}]

LucasCube

Entity["Graph",{"Wheel",n}]["LucasCube"]

seq=Table[GraphData[{"Wheel",n},"LucasCube"],{n,4,20}]

MatchingNumber

seq=Table[GraphData[{"Wheel",n},"MatchingNumber"],{n,4,20}]

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

MaximalCliqueCount

seq=Table[GraphData[{"Wheel",n},"MaximalCliqueCount"],{n,4,20}]

MaximalIndependentEdgeSetCount

A284709

seq=Table[GraphData[{"Wheel",n},"MaximalIndependentEdgeSetCount"],{n,4,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{0,3,2,-3,-4,0,2,1},{3,10,10,20,28,42,63,92},{-2,1}]

LinearRecurrence[{0,3,2,-3,-4,0,2,1},{2,1,4,3,10,10,20,28,42,63,92},37]

FindSequenceFunction[seq,n-3]

gf=x FindGeneratingFunction[{2,1,4,3,10,10,20,28,42,63,92,132,194,273,394,555,786,1105,1550,2166,3022,4200,5832,8073,11162,15400,21218,29187,40098,55013,75392,103199,141122,192786,263128,358820,488918,665667,905656,1231308},x]

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

gf=(x^4)FindGeneratingFunction[{3,10,10,20,28,42,63,92,132,194,273,394,555,786,1105,1550,2166,3022,4200,5832,8073,11162,15400,21218,29187,40098,55013,75392,103199,141122,192786,263128,358820,488918,665667,905656,1231308},x]

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

FindSequenceFunction[seq2={2,1,4,3,10,10,20,28,42,63,92,132,194,273,394,555,786,1105,1550,2166},n]

gf=x FindGeneratingFunction[seq2,x]

StringReplace[ToString[((x (-2-x+2 (x^2)+4 (x^3)-2 (x^4)-4 (x^5)+(x^7)))/((-1+(x^2)) (((-1+(x^2)+(x^3)))^2))),InputForm]," "->""]

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

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

MaximalIndependentVertexSetCount

A290612

seq=Table[GraphData[{"Wheel",n},"MaximalIndependentVertexSetCount"],{n,4,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{1,1,0,-1},{4,3,6,6,8},50]

FindSequenceFunction[seq,n-3]

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

FindSequenceFunction[{4,1,3,4,3,6,6,8,11,13,18,23,30,40,52,69,91,120,159,210},n]//FullSimplify

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

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

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

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

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

CoefficientList[Series[((4-x-(x^2)-3 (x^3))/(1-x-(x^2)+(x^4))),{x,0,20}],x]

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

MaximalIrredundantSetCount

A291063

seq=Table[GraphData[{"Wheel",n},"MaximalIrredundantSetCount"],{n,4,20}]

seq={1,3,4,7,11,12,15,15,31,63,67,100,144,213,344,479,698,993,1502,2247,3252,4777,6970,10284,15211,22298,32728,47985,70645,103962,152707,224383,329509,484452,712275,1046737,1538165,2260110,3321933,4882575,7175739};

coef=FindLinearRecurrence[seq]

Take[seq,Length@coef]

LinearRecurrence[{1,1,0,0,0,-1,-1,-1,1,3,-1,-1,0,-1,1},{1,3,4,7,11,12,15,15,31,63,67,100,144,213,344},20]

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

gf=(((x^2) (1+2 x-6 (x^5)-7 (x^6)-8 (x^7)+9 (x^8)+30 (x^9)-11 (x^10)-12 (x^11)-14 (x^13)+15 (x^14)))/((1-x) (1-(x^2)-(x^3)-(x^4)-(x^5)+(x^7)+2 (x^8)+(x^9)-2 (x^10)-(x^11)+(x^14))));

CoefficientList[Series[((1+2 x-6 (x^5)-7 (x^6)-8 (x^7)+9 (x^8)+30 (x^9)-11 (x^10)-12 (x^11)-14 (x^13)+15 (x^14))/((1-x) (1-(x^2)-(x^3)-(x^4)-(x^5)+(x^7)+2 (x^8)+(x^9)-2 (x^10)-(x^11)+(x^14)))),{x,0,20}],x]

res=Refine[SeriesCoefficient[gf,{x,0,n}],n>1]

terms=List@@(res-1);

N[terms/.n->1]//Chop

terms[[All,1]]

Table[1+RootSum[1-#^3-2 #^4+#^5+2 #^6+#^7-#^9-#^10-#^11-#^12+#^14&,((#)^(n-1))&],{n,2,20}]

1+RootSum[1-#^3-2 #^4+#^5+2 #^6+#^7-#^9-#^10-#^11-#^12+#^14&,((#)^(Range[20]))&]

MaximumCliqueCount

seq=Table[GraphData[{"Wheel",n},"MaximumCliqueCount"],{n,4,20}]

MaximumIndependentEdgeSetCount

seq=Table[GraphData[{"Wheel",n},"MaximumIndependentEdgeSetCount"],{n,4,20}]

seq[[2;;All;;2]]

FindSequenceFunction[%,n]//Factor

Simplify[2 (2+2 n+(n^2))/.n->(n-3)/2]

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

%==seq

MaximumIndependentVertexSetCount

seq=Table[GraphData[{"Wheel",n},"MaximumIndependentVertexSetCount"],{n,4,20}]

Table[Piecewise[{{4,n==4},{n-1,Mod[n,2]==0},{2,Mod[n,2]==1}}],{n,4,20}]

%==seq

MaximumLeafNumber

seq=Table[GraphData[{"Wheel",n},"MaximumLeafNumber"],{n,4,20}]

MaximumVertexDegree

seq=Table[GraphData[{"Wheel",n},"MaximumVertexDegree"],{n,4,20}]

MeanDistance

seq=Table[GraphData[{"Wheel",n},"MeanDistance"],{n,4,20}]

FindSequenceFunction[seq,n-3]//Factor

MinimalDominatingSetCount

A290270

seq=Table[GraphData[{"Wheel",n},"MinimalDominatingSetCount"],{n,4,20}]

FindLinearRecurrence[DeleteMissing@seq]

FindSequenceFunction[DeleteMissing@seq,n-3]

FindSequenceFunction[Rest@DeleteMissing@seq,n-4]

gf=(x^4)FindGeneratingFunction[DeleteMissing@seq,x]

seq={3,4,7,6,6,15,15,22,28,45,58,79,115,159,223,307,438,609,852,1194,1675,2347,3282,4606,6451,9040,12663,17749,24871,34845,48831,68424,95883,134350,188266,263811,369667,518002,725860,1017129,1425262,1997179,2798583};

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

FullSimplify[1+RootSum[1-#1^2-#1^3-#1^4+#1^6&,((#)^(n-1))&]]

coef=FindLinearRecurrence[seq]

eqns=Append[Table[a[k+2]==seq[[k]],{k,Length[coef]}],a[n]==Sum[coef[[k]]a[n-k],{k,Length[coef]}]]

Recurrence

RSolve[eqns,a[n],n]

FindSequenceFunction[seq,n-2]

gf=x FindGeneratingFunction[seq,x]

term=Refine[SeriesCoefficient[gf,{x,0,n}],n>0]

MinimalDominatingSetSignature

Table[GraphData[{"Wheel",n},"MinimalDominatingSetSignature"],{n,4,20}]//Column

MinimalEdgeCoverCount

A290471

seq=Table[GraphData[{"Wheel",n},"MinimalEdgeCoverCount"],{n,4,20}]

seq={1,5,7,17,31,52,99,169,301,536,947,1698,3043,5482,9919,17993,32743,59713,109099,199634,365719,670605,1230547,2259286,4149841,7624904,14013499,25759764,47358741,87077529,160120891,294453673,541509775,995888884,1831584239};

coef=FindLinearRecurrence[DeleteMissing@seq]

Take[seq,Length[coef]]

LinearRecurrence[{1,5,7,17,31,52,99,169,301},{1,3,1,-5,-5,0,4,3,1},20]

FindSequenceFunction[DeleteMissing@seq,n-3]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

Series[gf,{x,0,20}]

CoefficientList[Series[((-1-4 x+(x^2)+6 (x^3)+7 (x^4)+7 (x^5)+3 (x^6)+(x^7))/((((-1+(x^2)+(x^3)))^2) (-1+x+(x^2)+(x^3)))),{x,0,20}],x]

res=Refine[SeriesCoefficient[gf,{x,0,n}],n>0]

RootReduce[res]//FullSimplify

f1=-1-#1+((#1)^3)&;
f2=148035889-529 ((#1)^2)+((#1)^3)&;
pos=Range[3];

an=ToNumberField[Root[f2,pos[[#]]],Root[f1,#]]&/@Range[Length[pos]]

Equal@@Last/@an

RootSum[f1,Evaluate[((#)^(n+Range[Length[pos]]-1)).an[[1,2]]]&]

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

Table[((Root[-1-#1+((#1)^3)&,1])^(1+n)) Root[148035889-529 ((#1)^2)+((#1)^3)&,1]+((Root[-1-#1+((#1)^3)&,2])^(1+n)) Root[148035889-529 ((#1)^2)+((#1)^3)&,2]+((Root[-1-#1+((#1)^3)&,3])^(1+n)) Root[148035889-529 ((#1)^2)+((#1)^3)&,3],{n,10}]//N//Chop

f1=-1-#1+((#1)^3)&;
f2=-32181715+194672 #1-529 ((#1)^2)+((#1)^3)&;
pos={1,3,2};

an=ToNumberField[Root[f2,pos[[#]]],Root[f1,#]]&/@Range[Length[pos]]

Equal@@Last/@an

RootSum[f1,Evaluate[((#)^(n+Range[Length[pos]]-1)).an[[1,2]]]&]

Table[23 RootSum[-1-#1+((#1)^3)&,-((#1)^n)-8 ((#1)^(1+n))+13 ((#1)^(2+n))&],{n,10}]

Table[((Root[-1-#1+((#1)^3)&,3])^(1+n)) Root[-32181715+194672 #1-529 ((#1)^2)+((#1)^3)&,2]+((Root[-1-#1+((#1)^3)&,2])^(1+n)) Root[-32181715+194672 #1-529 ((#1)^2)+((#1)^3)&,3]+((Root[-1-#1+((#1)^3)&,1])^(2+n)) Root[-32181715+24334 #1+529 ((#1)^2)+((#1)^3)&,1],{n,10}]//N//Chop

Table[(1/529) (((Root[-1-#1+((#1)^3)&,1])^(1+n)) Root[148035889-529 ((#1)^2)+((#1)^3)&,1]+((Root[-1-#1+((#1)^3)&,2])^(1+n)) Root[148035889-529 ((#1)^2)+((#1)^3)&,2]+((Root[-1-#1+((#1)^3)&,3])^(1+n)) Root[148035889-529 ((#1)^2)+((#1)^3)&,3]+529 (((Root[-1-#1-((#1)^2)+((#1)^3)&,1])^n)+((Root[-1-#1-((#1)^2)+((#1)^3)&,2])^n)+((Root[-1-#1-((#1)^2)+((#1)^3)&,3])^n))+n (((Root[-1-#1+((#1)^3)&,3])^(1+n)) Root[-32181715+194672 #1-529 ((#1)^2)+((#1)^3)&,2]+((Root[-1-#1+((#1)^3)&,2])^(1+n)) Root[-32181715+194672 #1-529 ((#1)^2)+((#1)^3)&,3]+((Root[-1-#1+((#1)^3)&,1])^(2+n)) Root[-32181715+24334 #1+529 ((#1)^2)+((#1)^3)&,1])),{n,10}]//Round

Table[(1/529) (-529 RootSum[-1-#1+((#1)^3)&,-((#1)^(n+1))+((#1)^(n+3))&]+529 (RootSum[-1-#1-((#1)^2)+((#1)^3)&,((#)^n)&])+n 23 RootSum[-1-#1+((#1)^3)&,-((#1)^(n+1))-8 ((#1)^(n+2))+13 ((#1)^(n+3))&]),{n,10}]

FullSimplify[(1/529) (-529 RootSum[-1-#1+((#1)^3)&,-((#1)^(n+1))+((#1)^(n+3))&]+529 (RootSum[-1-#1-((#1)^2)+((#1)^3)&,((#)^n)&])+n 23 RootSum[-1-#1+((#1)^3)&,-((#1)^(n+1))-8 ((#1)^(n+2))+13 ((#1)^(n+3))&])]

Table[RootSum[-1-#-((#)^2)+((#)^3)&,((#)^n)&]-RootSum[-1-#+((#)^3)&,-((#)^(1+n))+((#)^(3+n))&]+ n RootSum[-1-#+((#)^3)&,-((#)^(n+1))-8 ((#)^(n+2))+13 ((#)^(n+3))&]/23,{n,10}]

MinimumCliqueCoveringCount

seq=Table[GraphData[{"Wheel",n},"MinimumCliqueCoveringCount"],{n,4,20}]

Table[Piecewise[{{1,n==4},{n-1,Mod[n,2]==0},{2,Mod[n,2]==1}}],{n,4,20}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"Wheel",n},"MinimumConnectedDominatingSetCount"],{n,4,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"Wheel",n},"MinimumDistinguishingLabelingCount"],{n,4,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-3]

(x^3)FindGeneratingFunction[seq,x]

MinimumDominatingSetCount

seq=Table[GraphData[{"Wheel",n},"MinimumDominatingSetCount"],{n,4,20}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"Wheel",n},"MinimumEdgeCoverCount"],{n,4,20}]

seq[[2;;All;;2]]

FindSequenceFunction[%,n]

5+8 n+3 (n^2)/.n->(n-3)/2//Factor

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

%==seq

MinimumVertexDegree

seq=Table[GraphData[{"Wheel",n},"MinimumVertexDegree"],{n,4,20}]

MolecularTopologicalIndex

seq=Table[GraphData[{"Wheel",n},"MolecularTopologicalIndex"],{n,4,20}]

FindSequenceFunction[seq,n-3]//Factor

Nonhamiltonian

Table[GraphData[{"Wheel",n},"Nonhamiltonian"],{n,4,20}]

NotationRules

Table[GraphData[{"Wheel",n},"NotationRules","Polyhedral"],{n,4,20}]

seq=DeleteMissing[%][[All,-1]]

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

OddChordlessCycleCount

seq=Table[GraphData[{"Wheel",n},"OddChordlessCycleCount"],{n,4,20}]

Table[Piecewise[{{0,n==4},{1,Mod[n,2]==0},{0,Mod[n,2]==1}}],{n,4,20}]

%==seq

PathCount

A291919

seq=Table[GraphData[{"Wheel",n},"PathCount"],{n,4,20}]

FindSequenceFunction[DeleteMissing@seq,n-3]//Factor

seq=Table[(n-1)(2n^3-12n^2+43n-48)/6,{n,40}]

coef=FindLinearRecurrence[DeleteMissing@seq]

Take[seq,Length@coef]

LinearRecurrence[{5,-10,10,-5,1},{0,1,9,30,78},20]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((x(1+4 x-5 (x^2)+8 (x^3)))/(((-1+x))^5)),{x,0,20}],x]

PathPolynomial

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

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

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Pell

Entity["Graph",{"Wheel",n}]["Pell"]

seq=Table[GraphData[{"Wheel",n},"Pell"],{n,4,20}]

PentagonCount

seq=Table[GraphData[{"Wheel",n},"PentagonCount"],{n,4,20}]

Perfect

Table[GraphData[{"Wheel",n},"Perfect"],{n,4,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"Wheel",n},"ProjectivePlaneCrossingNumber"],{n,4,20}]

Radius

seq=Table[GraphData[{"Wheel",n},"Radius"],{n,4,20}]

RectilinearCrossingNumber

seq=Table[GraphData[{"Wheel",n},"RectilinearCrossingNumber"],{n,4,20}]

Skewness

seq=Table[GraphData[{"Wheel",n},"Skewness"],{n,4,20}]

SpanningTreeCount

seq=Table[GraphData[{"Wheel",n},"SpanningTreeCount"],{n,4,20}]

FindSequenceFunction[seq,n-3]//FullSimplify

Table[LucasL[2(n-1)]-2,{n,4,20}]

Table[2 ChebyshevT[n-1,3/2]-2,{n,4,20}]

(Nonisomorphic) SpanningTreeCount

A002985

Table[Length[Union[CanonicalGraph/@SpanningTrees[WheelGraph[n]]]],{n,4,9}]//Timing

seq=Import["https://oeis.org/A002985/b002985.txt","Table"][[All,-1]]

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

Head/@Table[FindLinearRecurrence[Drop[seq,k]],{k,5}]//Union//Timing

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

d[n_]:=(84+12*(-1)^n+6*I*((-I)^n-I^n)+(85+3*(-1)^n)*n+24*n^2+2*n^3)/96

b[n_]:=SeriesCoefficient[Product[(((1-(x^k)))^(-Ceiling[k/2])),{k,n}],{x,0,n}]

Table[b[n-1]-d[n-3],{n,20}]

Table[Product[(((1-(x^k)))^(-Ceiling[k/2])),{k,n}],{n,5}]

Product[(((1-(x^k)))^(-k/2)),{k,n}]

Table[d[n],{n,0,20}]

Series[1/((1-x)^2*(1-x^2)*(1-x^4)),{x,0,20}]

FullSimplify[SeriesCoefficient[1/((1-x)^2*(1-x^2)*(1-x^4)),{x,0,n}],n≥0&&n∈Integers]//Factor

seq=Table[(84+12 (((-1))^n)+85 n+3 (((-1))^n) n+24 (n^2)+2 (n^3)+12 Sin[((n π)/2)])/96,{n,0,50}]

FindLinearRecurrence[seq]

FindGeneratingFunction[seq,x]

CoefficientList[Series[(1/((((-1+x))^4) (((1+x))^2) (1+(x^2)))),{x,0,20}],x]

SquareCount

seq=Table[GraphData[{"Wheel",n},"SquareCount"],{n,4,20}]

StabilityIndex

seq=Table[GraphData[{"Wheel",n},"StabilityIndex"],{n,4,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-3]

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

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

TopologicalIndex

seq=Table[GraphData[{"Wheel",n},"TopologicalIndex"],{n,4,20}]

FindSequenceFunction[seq,n-3]//FullSimplify

ToroidalCrossingNumber

seq=Table[GraphData[{"Wheel",n},"ToroidalCrossingNumber"],{n,4,20}]

Traceable

Table[GraphData[{"Wheel",n},"Traceable"],{n,4,20}]

TriangleCount

seq=Table[GraphData[{"Wheel",n},"TriangleCount"],{n,4,20}]

Untraceable

Table[GraphData[{"Wheel",n},"Untraceable"],{n,4,20}]

VertexConnectivity

Table[GraphData[{"Wheel",n},"VertexConnectivity"],{n,4,20}]

VertexCoverNumber

Related to but not the same as IndependenceNumber

seq=Table[GraphData[{"Wheel",n},"VertexCoverNumber"],{n,4,20}]

Table[1+Floor[n/2],{n,4,20}]

VertexCount

seq=Table[GraphData[{"Wheel",n},"VertexCount"],{n,4,20}]

FindSequenceFunction[seq,n-3]

VertexDegrees

seq=Table[GraphData[{"Wheel",n},"VertexDegrees"],{n,4,6}]

WienerIndex

A002378

seq=Table[GraphData[{"Wheel",n},"WienerIndex"],{n,4,20}]

Table[WienerIndex[Wheel[n]],{n,20}]

FindSequenceFunction[seq,n-3]//Factor

Table[(n-1)(n-2),{n,4,20}]

WienerSumIndex

seq=Table[GraphData[{"Wheel",n},"WienerSumIndex"],{n,4,20}]

FindSequenceFunction[seq,n-3]

(x^3)FindGeneratingFunction[seq,x]

Embeddings

<<MathWorld`Graphs`

{"Wheel", 4}

Names

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

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

Primary

GraphData[{"Wheel",4}]//StyleGraphs

Wheel construction

Flatten[MyWheelGraph[4,GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Planar

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

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

GraphEmbedding/@%

MinimalCrossing

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

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

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",4}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",4}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

Default embedding

g=Graph@GraphData[{"Wheel",4},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing Construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Wheel",4}]]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D All

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

3D Polyhedron

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",4},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",4},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",4},"Polyhedron","Canonical"],Yellow,Sphere[]}]

{"Wheel", 5}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",5}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",5},"VertexList"],GraphData[{"Wheel",5},"Edges"]]]

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

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

PolyhedronGraph[GraphData[{"Wheel",5},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",5},"Polyhedron"],{1,1,1,7Pi/6}]

GraphPlot@

g=;

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",5},"Planar"]

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

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

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",5}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",5}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction 3

GraphPlot@RotateGraph[,-2Pi/3]

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

RecognizeGraph[g]

MyWheelGraph[5,GraphLayout->"TriangularEmbedding"]

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

(g=MinimalCrossingGraph[GraphData[{"Wheel",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[{"Wheel",5},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",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[{"Wheel",5},"LocalCrossingNumber"]

GraphData[{"Wheel",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[{"Wheel",5}],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

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

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

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

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

gs=LineGraph/@%

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",5},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",5},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",5},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[4]]

RecognizeGraph[g]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",5}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 6}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",6}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

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

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

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{1,1,0}]

g=PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",6},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",6},"Planar"]

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",6}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",6}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3

GraphPlot@RotateGraph[,-2Pi/3]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

(g=MinimalCrossingGraph[GraphData[{"Wheel",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[{"Wheel",6},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",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[{"Wheel",6},"LocalCrossingNumber"]

GraphData[{"Wheel",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[{"Wheel",6}],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

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

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

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

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

RecognizeGraph@g

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",6},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",6},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",6},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[5]]

RecognizeGraph[g]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",6}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 7}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",7}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Wheel",7},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",7},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",7},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",7},"Planar"]

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",7}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",7}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 7

GraphPlot[RotateGraph[,-2Pi/3]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",7},"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[{"Wheel",7},"LocalCrossingNumber"]

GraphData[{"Wheel",7},"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[{"Wheel",7}],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

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

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

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

GraphPlot@RotateGraph[,{1,6}]

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",7},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",7},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",7},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[6]]

RecognizeGraph[g]

{"Wheel", 8}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",8}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Wheel",8},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",8},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",8},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",8},"Planar"]

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",8}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",8}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",8},"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[{"Wheel",8},"LocalCrossingNumber"]

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

MinimalLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

GraphPlot@

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

UnitDistanceGraphEmbeddingQ[%]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",8},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",8},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",8},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",8}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",8}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",8},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 9}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",9}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Wheel",9},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",9},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",9},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",9},"Planar"]

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",9}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",9}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",9},"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[{"Wheel",9},"LocalCrossingNumber"]

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

MinimalLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",9},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",9},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",9},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",9}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",9}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",9},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 10}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",10}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

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

PolyhedronGraph[GraphData[{"Wheel",10},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",10},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",10},"Planar"]

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",10}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",10}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",10},"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[{"Wheel",10},"LocalCrossingNumber"]

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

MinimalLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

GraphPlot@

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",10},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",10},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",10},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",10}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",10}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",10},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 11}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",11}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

GraphData[{"Wheel",11},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",11},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",11},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",11},"Planar"]

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

Planar construction

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

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

PlanarGraphEmbeddings

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

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",11}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",11}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",11},"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[{"Wheel",11},"LocalCrossingNumber"]

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

MinimalLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",11},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",11},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",11},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",11}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",11}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",11},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 12}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",12}[[2]],GraphLayout->#]&/@{"RadialEmbedding","TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",12}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",12},"VertexList"],GraphData[{"Wheel",12},"Edges"]]]

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

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

PolyhedronGraph[GraphData[{"Wheel",12},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",12},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",12}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",12},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Wheel",12}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",12}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",12}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",12}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",12},"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[{"Wheel",12},"LocalCrossingNumber"]

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

MinimalLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

GraphData[{"Wheel",12},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",12}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",12},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",12},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",12},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",12},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",12}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",12}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",12},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 13}

Names

GraphData[{"Wheel",13},"StandardName"]

GraphData[{"Wheel",13},"StandardNames"]

Primary

GraphData[{"Wheel",13}]//StyleGraphs[#,ImageSize->Small]&

Wheel construction

Flatten[MyWheelGraph[{"Wheel",13}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

GraphData[{"Wheel",13},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",13}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",13},"VertexList"],GraphData[{"Wheel",13},"Edges"]]]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Wheel",13},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Wheel",13},"Graph","Degenerate"]

Configuration

GraphData[{"Wheel",13},"Configuration"]

GraphData[{"Wheel",13},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Wheel",13},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Wheel",13},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",13},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",13},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

GraphData[{"Wheel",13},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Wheel",13},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Wheel",13},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Wheel",13},"Graph","Bilateral"]//StyleGraphs

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

Circular

GraphData[{"Wheel",13},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Wheel",13},"Hamiltonian"]

GraphData[{"Wheel",13},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",13}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",13},"Planar"]

GraphData[{"Wheel",13},"Graph","Planar"]//StyleGraphs

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Wheel",13}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",13}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",13}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",13}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Wheel",13},{"RCN","CN"}]

GraphData[{"Wheel",13},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",13},"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[{"Wheel",13},"LocalCrossingNumber"]

GraphData[{"Wheel",13},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

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

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

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

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

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

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

Circulant

GraphData[{"Wheel",13},"Circulant"]

GraphData[{"Wheel",13},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Wheel",13},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",13}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",13},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",13},"ComplementGraph","Name"]

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",13},"Line"]

LineGraphQ[GraphData[{"Wheel",13}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",13}&]

RootGraph[GraphData[{"Wheel",13}]]

RecognizeGraph[%]

Halin

GraphData[{"Wheel",13},"Halin"]

GraphData[{"Wheel",13},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",13},"Rigid"]

GraphData[{"Wheel",13},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",13},"Flexible"]

GraphData[{"Wheel",13},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",13},"LCF"]

GraphData[{"Wheel",13},"HamiltonianCycleCount"]

GraphData[{"Wheel",13},"LCFSignature"]

GraphData[{"Wheel",13},"LCFNotations"]

GraphData[{"Wheel",13},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"Wheel",13},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",13}],Debug->True]//Timing

GraphData[{"Wheel",13},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",13},"VertexList"],GraphData[{"Wheel",13},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Wheel",13},"Matchstick"]

GraphData[{"Wheel",13},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",13},"Edges"]]

3D All

GraphData[{"Wheel",13},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",13},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",13},"Polyhedral"]

GraphData[{"Wheel",13},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",13},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",13},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",13},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",13}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",13}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",13},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 14}

Names

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

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

Primary

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

Wheel construction

Flatten[MyWheelGraph[{"Wheel",14}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",14}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",14},"VertexList"],GraphData[{"Wheel",14},"Edges"]]]

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

Perspective construction

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

PolyhedronGraph[GraphData[{"Wheel",14},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",14},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"Wheel",14},"Hamiltonian"]

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

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",14}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",14},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"Wheel",14}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",14}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",14}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",14}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

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

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",14},"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[{"Wheel",14},"LocalCrossingNumber"]

GraphData[{"Wheel",14},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

GraphData[{"Wheel",14},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",14}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",14},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",14},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",14},"Line"]

LineGraphQ[GraphData[{"Wheel",14}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",14}&]

RootGraph[GraphData[{"Wheel",14}]]

RecognizeGraph[%]

Halin

GraphData[{"Wheel",14},"Halin"]

GraphData[{"Wheel",14},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",14},"Rigid"]

GraphData[{"Wheel",14},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",14},"Flexible"]

GraphData[{"Wheel",14},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",14},"LCF"]

GraphData[{"Wheel",14},"HamiltonianCycleCount"]

GraphData[{"Wheel",14},"LCFSignature"]

GraphData[{"Wheel",14},"LCFNotations"]

GraphData[{"Wheel",14},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Wheel",14},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",14}],Debug->True]//Timing

GraphData[{"Wheel",14},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",14},"VertexList"],GraphData[{"Wheel",14},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Wheel",14},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Wheel",14}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Wheel",14},"Matchstick"]

GraphData[{"Wheel",14},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",14},"Edges"]]

3D All

GraphData[{"Wheel",14},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",14},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",14},"Polyhedral"]

GraphData[{"Wheel",14},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",14},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",14},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",14},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",14}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",14}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",14},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 15}

Names

GraphData[{"Wheel",15},"StandardName"]

GraphData[{"Wheel",15},"StandardNames"]

Primary

GraphData[{"Wheel",15}]//StyleGraphs[#,ImageSize->Small]&

Wheel construction

Flatten[MyWheelGraph[{"Wheel",15}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

GraphData[{"Wheel",15},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Wheel",15},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",15}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",15},"VertexList"],GraphData[{"Wheel",15},"Edges"]]]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Wheel",15},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Wheel",15},"Graph","Degenerate"]

Configuration

GraphData[{"Wheel",15},"Configuration"]

GraphData[{"Wheel",15},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Wheel",15},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Wheel",15},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",15},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",15},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

GraphData[{"Wheel",15},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Wheel",15},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Wheel",15},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Wheel",15},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Wheel",15},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Wheel",15},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Wheel",15},"Hamiltonian"]

GraphData[{"Wheel",15},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",15}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",15},"Planar"]

GraphData[{"Wheel",15},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Wheel",15}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Wheel",15}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",15}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",15}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",15}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Wheel",15},{"RCN","CN"}]

GraphData[{"Wheel",15},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Wheel",15}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",15}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",15}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",15}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",15}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",15}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Wheel",15}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",15},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Wheel",15},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Wheel",15}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Wheel",15},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",15},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Wheel",15}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",15},"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[{"Wheel",15},"LocalCrossingNumber"]

GraphData[{"Wheel",15},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Wheel",15}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",15}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",15},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",15}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",15},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Wheel",15},"Circulant"]

GraphData[{"Wheel",15},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Wheel",15},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",15}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",15},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",15},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",15},"Line"]

LineGraphQ[GraphData[{"Wheel",15}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",15}&]

RootGraph[GraphData[{"Wheel",15}]]

RecognizeGraph[%]

Halin

GraphData[{"Wheel",15},"Halin"]

GraphData[{"Wheel",15},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",15},"Rigid"]

GraphData[{"Wheel",15},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",15},"Flexible"]

GraphData[{"Wheel",15},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",15},"LCF"]

GraphData[{"Wheel",15},"HamiltonianCycleCount"]

GraphData[{"Wheel",15},"LCFSignature"]

GraphData[{"Wheel",15},"LCFNotations"]

GraphData[{"Wheel",15},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Wheel",15},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",15}],Debug->True]//Timing

GraphData[{"Wheel",15},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",15},"VertexList"],GraphData[{"Wheel",15},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Wheel",15},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Wheel",15}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Wheel",15},"Matchstick"]

GraphData[{"Wheel",15},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",15},"Edges"]]

3D All

GraphData[{"Wheel",15},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",15},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",15},"Polyhedral"]

GraphData[{"Wheel",15},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",15},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",15},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",15},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",15}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",15}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",15},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 16}

Names

GraphData[{"Wheel",16},"StandardName"]

GraphData[{"Wheel",16},"StandardNames"]

Primary

GraphData[{"Wheel",16}]//StyleGraphs[#,ImageSize->Small]&

Wheel construction

Flatten[MyWheelGraph[{"Wheel",16}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

GraphData[{"Wheel",16},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Wheel",16},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",16}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",16},"VertexList"],GraphData[{"Wheel",16},"Edges"]]]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Wheel",16},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Wheel",16},"Graph","Degenerate"]

Configuration

GraphData[{"Wheel",16},"Configuration"]

GraphData[{"Wheel",16},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Wheel",16},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Wheel",16},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",16},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",16},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

GraphData[{"Wheel",16},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Wheel",16},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Wheel",16},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Wheel",16},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Wheel",16},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Wheel",16},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Wheel",16},"Hamiltonian"]

GraphData[{"Wheel",16},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",16}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",16},"Planar"]

GraphData[{"Wheel",16},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Wheel",16}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Wheel",16}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",16}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",16}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",16}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Wheel",16},{"RCN","CN"}]

GraphData[{"Wheel",16},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Wheel",16}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",16}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",16}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",16}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",16}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",16}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Wheel",16}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",16},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Wheel",16},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Wheel",16}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Wheel",16},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",16},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Wheel",16}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",16},"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[{"Wheel",16},"LocalCrossingNumber"]

GraphData[{"Wheel",16},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Wheel",16}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",16}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",16},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",16}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",16},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Wheel",16},"Circulant"]

GraphData[{"Wheel",16},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Wheel",16},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",16}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",16},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",16},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",16},"Line"]

LineGraphQ[GraphData[{"Wheel",16}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",16}&]

RootGraph[GraphData[{"Wheel",16}]]

RecognizeGraph[%]

Halin

GraphData[{"Wheel",16},"Halin"]

GraphData[{"Wheel",16},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",16},"Rigid"]

GraphData[{"Wheel",16},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",16},"Flexible"]

GraphData[{"Wheel",16},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",16},"LCF"]

GraphData[{"Wheel",16},"HamiltonianCycleCount"]

GraphData[{"Wheel",16},"LCFSignature"]

GraphData[{"Wheel",16},"LCFNotations"]

GraphData[{"Wheel",16},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Wheel",16},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",16}],Debug->True]//Timing

GraphData[{"Wheel",16},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",16},"VertexList"],GraphData[{"Wheel",16},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Wheel",16},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Wheel",16}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Wheel",16},"Matchstick"]

GraphData[{"Wheel",16},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",16},"Edges"]]

3D All

GraphData[{"Wheel",16},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",16},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",16},"Polyhedral"]

GraphData[{"Wheel",16},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",16},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",16},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",16},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",16}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",16}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",16},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 17}

Names

GraphData[{"Wheel",17},"StandardName"]

GraphData[{"Wheel",17},"StandardNames"]

Primary

GraphData[{"Wheel",17}]//StyleGraphs[#,ImageSize->Small]&

Wheel construction

Flatten[MyWheelGraph[{"Wheel",17}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

GraphData[{"Wheel",17},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Wheel",17},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",17}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",17},"VertexList"],GraphData[{"Wheel",17},"Edges"]]]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Wheel",17},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Wheel",17},"Graph","Degenerate"]

Configuration

GraphData[{"Wheel",17},"Configuration"]

GraphData[{"Wheel",17},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Wheel",17},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Wheel",17},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",17},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",17},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

GraphData[{"Wheel",17},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Wheel",17},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Wheel",17},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Wheel",17},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Wheel",17},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Wheel",17},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Wheel",17},"Hamiltonian"]

GraphData[{"Wheel",17},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",17}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",17},"Planar"]

GraphData[{"Wheel",17},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Wheel",17}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Wheel",17}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",17}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",17}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",17}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Wheel",17},{"RCN","CN"}]

GraphData[{"Wheel",17},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Wheel",17}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",17}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",17}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",17}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",17}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",17}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Wheel",17}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",17},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Wheel",17},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Wheel",17}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Wheel",17},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",17},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Wheel",17}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",17},"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[{"Wheel",17},"LocalCrossingNumber"]

GraphData[{"Wheel",17},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Wheel",17}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",17}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",17},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",17}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",17},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Wheel",17},"Circulant"]

GraphData[{"Wheel",17},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Wheel",17},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",17}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",17},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",17},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",17},"Line"]

LineGraphQ[GraphData[{"Wheel",17}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",17}&]

RootGraph[GraphData[{"Wheel",17}]]

RecognizeGraph[%]

Halin

GraphData[{"Wheel",17},"Halin"]

GraphData[{"Wheel",17},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",17},"Rigid"]

GraphData[{"Wheel",17},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",17},"Flexible"]

GraphData[{"Wheel",17},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",17},"LCF"]

GraphData[{"Wheel",17},"HamiltonianCycleCount"]

GraphData[{"Wheel",17},"LCFSignature"]

GraphData[{"Wheel",17},"LCFNotations"]

GraphData[{"Wheel",17},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Wheel",17},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",17}],Debug->True]//Timing

GraphData[{"Wheel",17},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",17},"VertexList"],GraphData[{"Wheel",17},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Wheel",17},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Wheel",17}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Wheel",17},"Matchstick"]

GraphData[{"Wheel",17},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",17},"Edges"]]

3D All

GraphData[{"Wheel",17},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",17},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",17},"Polyhedral"]

GraphData[{"Wheel",17},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",17},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",17},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",17},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",17}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",17}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",17},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 18}

Names

GraphData[{"Wheel",18},"StandardName"]

GraphData[{"Wheel",18},"StandardNames"]

Primary

GraphData[{"Wheel",18}]//StyleGraphs[#,ImageSize->Small]&

Wheel construction

Flatten[MyWheelGraph[{"Wheel",18}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

GraphData[{"Wheel",18},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Wheel",18},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",18}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",18},"VertexList"],GraphData[{"Wheel",18},"Edges"]]]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Wheel",18},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Wheel",18},"Graph","Degenerate"]

Configuration

GraphData[{"Wheel",18},"Configuration"]

GraphData[{"Wheel",18},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Wheel",18},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Wheel",18},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",18},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",18},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

GraphData[{"Wheel",18},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Wheel",18},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Wheel",18},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Wheel",18},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Wheel",18},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Wheel",18},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Wheel",18},"Hamiltonian"]

GraphData[{"Wheel",18},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",18}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",18},"Planar"]

GraphData[{"Wheel",18},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Wheel",18}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Wheel",18}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",18}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",18}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",18}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Wheel",18},{"RCN","CN"}]

GraphData[{"Wheel",18},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Wheel",18}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",18}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",18}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",18}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",18}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",18}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Wheel",18}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",18},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Wheel",18},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Wheel",18}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Wheel",18},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",18},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Wheel",18}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",18},"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[{"Wheel",18},"LocalCrossingNumber"]

GraphData[{"Wheel",18},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Wheel",18}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",18}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",18},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",18}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",18},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Wheel",18},"Circulant"]

GraphData[{"Wheel",18},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Wheel",18},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",18}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",18},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",18},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",18},"Line"]

LineGraphQ[GraphData[{"Wheel",18}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",18}&]

RootGraph[GraphData[{"Wheel",18}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"Wheel",18},"Halin"]

GraphData[{"Wheel",18},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",18},"Rigid"]

GraphData[{"Wheel",18},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",18},"Flexible"]

GraphData[{"Wheel",18},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",18},"LCF"]

GraphData[{"Wheel",18},"HamiltonianCycleCount"]

GraphData[{"Wheel",18},"LCFSignature"]

GraphData[{"Wheel",18},"LCFNotations"]

GraphData[{"Wheel",18},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Wheel",18},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",18}],Debug->True]//Timing

GraphData[{"Wheel",18},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",18},"VertexList"],GraphData[{"Wheel",18},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Wheel",18},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Wheel",18}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Wheel",18},"Matchstick"]

GraphData[{"Wheel",18},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",18},"Edges"]]

3D All

GraphData[{"Wheel",18},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",18},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",18},"Polyhedral"]

GraphData[{"Wheel",18},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",18},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",18},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",18},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",18}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",18}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",18},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 19}

Names

GraphData[{"Wheel",19},"StandardName"]

GraphData[{"Wheel",19},"StandardNames"]

Primary

GraphData[{"Wheel",19}]//StyleGraphs[#,ImageSize->Small]&

Wheel construction

Flatten[MyWheelGraph[{"Wheel",19}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

GraphData[{"Wheel",19},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Wheel",19},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",19}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",19},"VertexList"],GraphData[{"Wheel",19},"Edges"]]]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Wheel",19},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Wheel",19},"Graph","Degenerate"]

Configuration

GraphData[{"Wheel",19},"Configuration"]

GraphData[{"Wheel",19},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Wheel",19},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Wheel",19},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",19},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",19},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

GraphData[{"Wheel",19},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Wheel",19},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Wheel",19},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Wheel",19},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Wheel",19},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Wheel",19},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Wheel",19},"Hamiltonian"]

GraphData[{"Wheel",19},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",19}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",19},"Planar"]

GraphData[{"Wheel",19},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Wheel",19}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Wheel",19}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",19}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",19}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",19}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Wheel",19},{"RCN","CN"}]

GraphData[{"Wheel",19},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Wheel",19}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",19}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",19}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",19}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",19}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",19}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Wheel",19}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",19},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Wheel",19},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Wheel",19}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Wheel",19},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",19},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Wheel",19}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",19},"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[{"Wheel",19},"LocalCrossingNumber"]

GraphData[{"Wheel",19},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Wheel",19}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",19}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",19},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",19}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",19},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Wheel",19},"Circulant"]

GraphData[{"Wheel",19},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Wheel",19},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",19}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",19},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",19},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",19},"Line"]

LineGraphQ[GraphData[{"Wheel",19}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",19}&]

RootGraph[GraphData[{"Wheel",19}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"Wheel",19},"Halin"]

GraphData[{"Wheel",19},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",19},"Rigid"]

GraphData[{"Wheel",19},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",19},"Flexible"]

GraphData[{"Wheel",19},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",19},"LCF"]

GraphData[{"Wheel",19},"HamiltonianCycleCount"]

GraphData[{"Wheel",19},"LCFSignature"]

GraphData[{"Wheel",19},"LCFNotations"]

GraphData[{"Wheel",19},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Wheel",19},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",19}],Debug->True]//Timing

GraphData[{"Wheel",19},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",19},"VertexList"],GraphData[{"Wheel",19},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Wheel",19},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Wheel",19}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Wheel",19},"Matchstick"]

GraphData[{"Wheel",19},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",19},"Edges"]]

3D All

GraphData[{"Wheel",19},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",19},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",19},"Polyhedral"]

GraphData[{"Wheel",19},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",19},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",19},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",19},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",19}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",19}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",19},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Wheel", 20}

Names

GraphData[{"Wheel",20},"StandardName"]

GraphData[{"Wheel",20},"StandardNames"]

Primary

GraphData[{"Wheel",20}]//StyleGraphs[#,ImageSize->Small]&

Wheel construction

Flatten[MyWheelGraph[{"Wheel",20}[[2]],GraphLayout->#,Debug->True]&/@{"TriangularEmbedding","StarEmbeddings","CircularEmbedding"}]//StyleGraphs

All

GraphData[{"Wheel",20},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Wheel",20},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"Wheel",20}]]

Default embedding

GraphPlot[Graph[GraphData[{"Wheel",20},"VertexList"],GraphData[{"Wheel",20},"Edges"]]]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"Wheel",20},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Wheel",20},"Graph","Degenerate"]

Configuration

GraphData[{"Wheel",20},"Configuration"]

GraphData[{"Wheel",20},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"Wheel",20},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"Wheel",20},"Polyhedron"]

PolyhedronGraph[GraphData[{"Wheel",20},"Polyhedron"]]

Manipulate[PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{x,y,z}],{x,-1,1},{y,-1,1},{z,-1,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{0,.01,.01}]

PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{0,0,1}]

PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{0,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{1,0.01,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{1,1,0}]

PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{1,0,1,-Pi/2}]

PolyhedronProjectionGraph[GraphData[{"Wheel",20},"Polyhedron"],{1,1,1}]

HoneycombToroidal construction

GraphData[{"Wheel",20},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Wheel",20},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Wheel",20},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Wheel",20},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingQ[#],GraphSymmetryGroup[#]}&/@GraphData[{"Wheel",20},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Wheel",20},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Wheel",20},"Hamiltonian"]

GraphData[{"Wheel",20},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"Wheel",20}],All][[All,All,1]]]

circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"Wheel",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[{"Wheel",20},"Planar"]

GraphData[{"Wheel",20},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Wheel",20}],Method->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Wheel",20}]],10]

PlanarGraphEmbeddings

(plemb=PlanarGraphEmbeddings[GraphData[{"Wheel",20}]])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Wheel",20}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Wheel",20}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Wheel",20},{"RCN","CN"}]

GraphData[{"Wheel",20},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Wheel",20}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",20}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",20}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",20}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",20}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Wheel",20}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Wheel",20}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",20},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Wheel",20},"V"]&]

(gs=Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Wheel",20}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Wheel",20},"V"]&]])//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",20},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Wheel",20}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",20},"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[{"Wheel",20},"LocalCrossingNumber"]

GraphData[{"Wheel",20},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"Wheel",20}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",20}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",20},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Wheel",20}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Wheel",20},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"Wheel",20},"Circulant"]

GraphData[{"Wheel",20},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Wheel",20},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Wheel",20}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Wheel",20},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Wheel",20},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Wheel",20},"Line"]

LineGraphQ[GraphData[{"Wheel",20}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"Wheel",20}&]

RootGraph[GraphData[{"Wheel",20}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"Wheel",20},"Halin"]

GraphData[{"Wheel",20},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Wheel",20},"Rigid"]

GraphData[{"Wheel",20},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Wheel",20},"Flexible"]

GraphData[{"Wheel",20},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Wheel",20},"LCF"]

GraphData[{"Wheel",20},"HamiltonianCycleCount"]

GraphData[{"Wheel",20},"LCFSignature"]

GraphData[{"Wheel",20},"LCFNotations"]

GraphData[{"Wheel",20},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"Wheel",20},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Wheel",20}],Debug->True]//Timing

GraphData[{"Wheel",20},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Wheel",20},"VertexList"],GraphData[{"Wheel",20},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Wheel",20},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Wheel",20}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Wheel",20},"Matchstick"]

GraphData[{"Wheel",20},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Wheel",20},"Edges"]]

3D All

GraphData[{"Wheel",20},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Wheel",20},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Wheel",20},"Polyhedral"]

GraphData[{"Wheel",20},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",20},"Polyhedron"]}]

3D Canonical

GraphData[{"Wheel",20},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Wheel",20},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[{"Wheel",20}[[2]]]]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Wheel",20}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Wheel",20},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]