Wheel Graph

Author

Eric W. Weisstein
August 2, 2023

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.

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

Figure

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 pyrmaid

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

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

{"Wheel", 4}

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

Primary

GraphData[{"Wheel",4}]//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}

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

All

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

Planar

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

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

GraphEmbedding/@%

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

Tutte embedding construction 3

GraphPlot@RotateGraph[,-2Pi/3]

e[l__]:=Sequence@@Partition[{l},2,1]

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]

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing Construction

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D All

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

3D Polyhedron

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]

{"Wheel", 6}

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

All

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

Planar

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

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

GraphEmbedding/@%

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

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]

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

Default embedding

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

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

RecognizeGraph[g]

3D All

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

3D Polyhedron

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]

{"Wheel", 7}

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

All

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

Planar

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

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

GraphEmbedding/@%

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

Tutte embedding construction 7

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

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

RecognizeGraph[g]

LCF

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

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

UnitDistance

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

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Wheel",7},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing Construction

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D All

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

3D Polyhedron

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

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

3D Canonical

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

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

3D canonical polyhedron

g=PolyhedronGraph[CanonicalPyramid[6]]

RecognizeGraph[g]

{"Wheel", 8}

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

All

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

Planar

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

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

Tutte embedding construction

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

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

RecognizeGraph[g]

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing Construction

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D All

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

3D Polyhedron

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",8},"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[7]]

RecognizeGraph[g]

{"Wheel", 9}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing Construction

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[8]]

RecognizeGraph[g]

{"Wheel", 10}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing Construction

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[9]]

RecognizeGraph[g]

{"Wheel", 11}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

MinimalCrossing Construction

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

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[10]]

RecognizeGraph[g]

{"Wheel", 12}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

MinimalCrossing Construction

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

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[11]]

RecognizeGraph[g]

{"Wheel", 13}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

MinimalCrossing Construction

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

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[12]]

RecognizeGraph[g]

{"Wheel", 14}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

MinimalCrossing Construction

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

3D All

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

3D Polyhedron

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Wheel",14},"Polyhedron"]},AspectRatio->1]

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[13]]

RecognizeGraph[g]

{"Wheel", 16}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

MinimalCrossing Construction

MinimalCrossingGraph[GraphData[{"Wheel",16}]]

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[15]]

RecognizeGraph[g]

{"Wheel", 17}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

MinimalCrossing Construction

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

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[16]]

RecognizeGraph[g]

{"Wheel", 18}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

Graph[GraphData[{"Wheel",18},"Edges"]]

MinimalCrossing Construction

MinimalCrossingGraph[GraphData[{"Wheel",18}]]

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[17]]

RecognizeGraph[g]

{"Wheel", 19}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

Graph@GraphData[{"Wheel",19},"Edges"]

RecognizeGraph[g]

MinimalCrossing Construction

MinimalCrossingGraph[GraphData[{"Wheel",19}]]

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[18]]

RecognizeGraph[g]

{"Wheel", 20}

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

All

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

LCF

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

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

UnitDistance

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

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

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

Matchstick

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

MinimalCrossing

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

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

Default embedding

Graph@GraphData[{"Wheel",20},"Edges"]

RecognizeGraph[g]

MinimalCrossing Construction

MinimalCrossingGraph[GraphData[{"Wheel",20}]]

3D All

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

3D Polyhedron

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

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

3D canonical polyhedron construction

g=PolyhedronGraph[CanonicalPyramid[19]]

RecognizeGraph[g]