Self-Dual Graph

Author

Eric W. Weisstein
October 26, 2024

This notebook downloaded from http://mathworld.wolfram.com/notebooks/GraphTheory/Self-DualGraph.nb.

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

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

Counts

A002841

1, 1, 2, 6, 16, 50, 165, 554, 1908, 6667, 23556, 84048, 302404, 1095536, 3993623

Do[(
Print[{n,Length[selfdual=Select[PolyhedralGraphs[n],IsomorphicGraphQ[#,DualGraph[#]]&]]//Timing}];
If[selfdual=!={},Export["/Developer/eww/Graphs/SelfDual/selfdual_"<>If[n<10,"0",""]<>ToString[n]<>".s6",selfdual,"Header"->False]]
),{n,4,10}]

Regular self-dual

GraphData[{"Regular","SelfDual"}]

Figure

GraphicsGrid[Partition[Show[StyleGraphs@GraphData[#],PlotLabel->TextCell[Style[GraphData[#,"Name"],Directive[14,Black,Italic,FontFamily->"Times"]],PageWidth->150,TextAlignment->Center]]&/@SortBy[DeleteCases[GraphData["SelfDual"],{"Wheel",_}],GraphData[#,"V"]&],UpTo[4]],ImageSize->700,Dividers->All,Alignment->Center]

Enumeration

GraphData

A002841

Length/@Table[GraphData["SelfDual",n],{n,9}]

Computed

SetDirectory["/Users/eww/Documents/Mathematica/Paclets/GraphData/Nodes/SelfDual"]

files=FileNames["*.s6"]

A002841

Length/@(selfdual=Import[#,{"Sparse6","GraphList"}]&/@files)

GraphicsGrid[Flatten[Partition[#,UpTo[10]]&/@selfdual,1],Dividers->All]

New

new=Cases[Flatten[MapIndexed[{{3,0}+#2,#,RecognizeGraph[#,"Cache"->"InternalOnly"]}&,Drop[selfdual,-2],{2}],1],{gn_,g_,{}}:>{gn,g}]

Length[new]

In GraphData

DeleteCases[Map[RecognizeGraph[#,"Cache"->"InternalOnly"]&,selfdual,{2}],{},∞]//Column

GraphData["SelfDual",10;;]

old=Flatten[DeleteCases[MapIndexed[Rule[{3,0}+#2,RecognizeGraph[#,"Cache"->"InternalOnly"]]&,selfdual,{2}],Rule[_,{}],∞]]

AlternateStandardNames

l={#2,{0,SortBy[Append[GraphData[#2,"AlternateStandardNames"],{"SelfDual",#1}],First[Flatten[{#}]]&]}}&@@@old

PropertyReplace[l,"AlternateStandardNames","13.1"]

RenameGraphFiles[]

AlternateNames

l={#2,{0,Union[GraphData[#2,"AlternateNames"],{"("<>StringRiffle[ToString/@#1,","]<>")\[Hyphen]self dual graph"}]}}&@@@old

PropertyReplace[l,"AlternateNames","13.1"]

RenameGraphFiles[]

NotationRules

l={#2,{0,Union[GraphData[#2,"NotationRules"],{"SelfDual"->#1}]}}&@@@old

PropertyReplace[l,"NotationRules","13.1"]

RenameGraphFiles[]

Embeddings

<<MathWorld`Graphs`

4

{"SelfDual", {4, 1}} == "TetrahedralGraph"

GraphData[{"SelfDual",{4,1}},"#"]

5

{"SelfDual", {5, 1}} == {"Wheel", 5}

GraphData[{"SelfDual",{5,1}},"#"]

6

GraphData["SelfDual",6]

{"SelfDual", {6, 1}} == {"PathComplement", 6}

GraphData[{"SelfDual",{6,1}},"#"]

{"SelfDual", {6, 2}} == {"Wheel", 6}

GraphData[{"SelfDual",{6,2}},"#"]

7

GraphData["SelfDual",7]

{"SelfDual", {7, 1}} == {"JohnsonSkeleton", 7}

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

ShowLabeledGraph[g1=AddEdges[AddVertices[ChangeVertices[WebGraph[3,2],Join[Through[{Cos,Sin}[π/2+2π #/3]]&/@Range[0,2],2Through[{Cos,Sin}[π/2+2π #/3]]&/@Range[0,2]]],{{0,0}}],{{7,1},{2,7},{7,3}}],AspectRatio->Automatic
]

g1=Graph[{{{1,2}},{{2,3}},{{1,3}},{{4,5}},{{5,6}},{{4,6}},{{1,4}},{{2,5}},{{3,6}},{{1,7}},{{2,7}},{{3,7}}},{{{0,1}},{{-Sqrt[3]/2,-1/2}},{{Sqrt[3]/2,-1/2}},{{0,2}},{{-Sqrt[3],-1}},{{Sqrt[3],-1}},{{0,0}}}];

{"SelfDual", {7, 2}} == {"Heptahedral", 18}

GraphData[{"SelfDual",{7,2}},"#"]

{"SelfDual", {7, 3}} == {"Heptahedral", 25}

GraphData[{"SelfDual",{7,3}},"#"]

{"SelfDual", {7, 4}} == {"Wheel", 7}

GraphData[{"SelfDual",{7,4}},"#"]

{"SelfDual", {7, 5}}

GraphData[{"SelfDual",{7,5}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SelfDual",{7,5}},"EdgeList"]]

Default embedding

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

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

RecognizeGraph[g]

GraphData[{"SelfDual",{7,5}}]//StyleGraphs

ShowLabeledGraph[g2=AddEdges[AddVertices[ChangeVertices[Cycle[4],{{0,0},{1,0},{1,1},{0,1}}],Table[{1,0}+{-1,1}n/4,{n,3}]],{{4,7},{7,6},{5,6},{2,5},{3,7},{1,7},{1,6},{1,5}}]
]

g2=Graph[{{{1,2}},{{2,3}},{{3,4}},{{1,4}},{{4,7}},{{6,7}},{{5,6}},{{2,5}},{{3,7}},{{1,7}},{{1,6}},{{1,5}}},{{{0,0}},{{1,0}},{{1,1}},{{0,1}},{{3/4,1/4}},{{1/2,1/2}},{{1/4,3/4}}}];

Degenerate

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

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

Bilateral

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

Circular

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

Circular construction

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

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

Planar

GraphData[{"SelfDual",{7,5}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"SelfDual",{7,5}},{"RCN","CN"}]

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

MinimalCrossing construction

MinimalCrossingGraph[GraphData[{"SelfDual",{7,5}}]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"SelfDual",{7,5}},"Circulant"]

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

Halin

GraphData[{"SelfDual",{7,5}},"Halin"]

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

Rigid

GraphData[{"SelfDual",{7,5}},"Rigid"]

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

Flexible

GraphData[{"SelfDual",{7,5}},"Flexible"]

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

LCF

GraphData[{"SelfDual",{7,5}},"LCF"]

GraphData[{"SelfDual",{7,5}},"HamiltonianCycleCount"]

GraphData[{"SelfDual",{7,5}},"LCFSignature"]

GraphData[{"SelfDual",{7,5}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SelfDual",{7,5}},"UnitDistance"]

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

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

Matchstick

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

3D All

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

3D Polyhedron

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

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

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

3D Polyhedron construction

poly=GraphPolyhedron[GraphData[{"SelfDual",{7,5}}]]

Graphics3D[{FaceForm[Green,Red],poly}]

Graphics3D[poly2=Polyhedron[Normalize/@poly[[1]],poly[[2]]]]

(can=FindCanonicalPolyhedron[poly2,WorkingPrecision->1000,MaxIterations->5000,PrecisionGoal->20])//Timing

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

SimplePolyhedronQ[can]

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

{"SelfDual", {7, 6}}

GraphData[{"SelfDual",{7,6}},"StandardName"]

Primary

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

All

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

Default embedding

GraphPlot@GraphData[{"SelfDual",{7,6}},"Edges"]

Mean[v[[{2,4,5}]]]//FullSimplify

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

RecognizeGraph[g]

Planar

GraphData[{"SelfDual",{7,6}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

MinimalCrossing

GraphData[{"SelfDual",{7,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Tutte embedding construction 4

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

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

RecognizeGraph[g]

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[,2Pi/3]]

Mean[v[[{4,6}]]]

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

RecognizeGraph[g]

LCF

GraphData[{"SelfDual",{7,6}},"LCFSignature"]

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

UnitDistance

GraphData[{"SelfDual",{7,6}},"UnitDistance"]

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

Matchstick

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

Default embedding

ShowLabeledGraph[g3=AddEdges[ChangeVertices[GraphUnion[Star[4],Cycle[3]],
Join[-.25Through[{Cos,Sin}[π/2+2π #/3]]&/@Range[0,2],{{0,0}},Through[{Cos,Sin}[π/2+2π #/3]]&/@Range[0,2]
]],{{3,6},{3,5},{1,6},{1,7},{2,7},{2,5}}],AspectRatio->Automatic]

g3=Graph[{{{1,4}},{{2,4}},{{3,4}},{{5,6}},{{6,7}},{{5,7}},{{3,6}},{{3,5}},{{1,6}},{{1,7}},{{2,7}},{{2,5}}},{{{0,-0.25}},{{0.21650635094610965,0.125}},{{-0.21650635094610965,0.125}},{{0,0}},{{0,1}},{{-Sqrt[3]/2,-1/2}},{{Sqrt[3]/2,-1/2}}}];

RecognizeGraph/@{g1,g2,g3}

GraphPlot@GraphData[{"SelfDual",{7,6}},"Edges"]

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

RecognizeGraph[g]

3D All

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],GraphPolyhedron[GraphData[{"SelfDual",{7,6}}],-1]}]

Graphics3D[poly2=Polyhedron[Normalize/@poly[[1]],poly[[2]]]]

(can=FindCanonicalPolyhedron[poly2,WorkingPrecision->1000,MaxIterations->5000,PrecisionGoal->20])//Timing

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

SimplePolyhedronQ[can]

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

8

GraphData["SelfDual",8]

{"SelfDual", {8, 1}}

GraphData[{"SelfDual",{8,1}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SelfDual",{8,1}},"EdgeList"]]

Default embedding

RotateGraph[Graph[GraphData[{"SelfDual",{8,1}},"Edges"],GraphLayout->"RadialEmbedding"],{2,3}]

c={{-1,0},{1,0},{0,Sqrt[3]}};
m=Mean[c]

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

RecognizeGraph[g]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

Degenerate

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

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

Bilateral

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

Circular

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

Circular construction

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

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

Planar

GraphData[{"SelfDual",{8,1}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction 4 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"SelfDual",{8,1}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

MinimalCrossingGraph[GraphData[{"SelfDual",{8,1}}]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"SelfDual",{8,1}},"Circulant"]

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

Halin

GraphData[{"SelfDual",{8,1}},"Halin"]

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

Rigid

GraphData[{"SelfDual",{8,1}},"Rigid"]

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

Flexible

GraphData[{"SelfDual",{8,1}},"Flexible"]

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

LCF

GraphData[{"SelfDual",{8,1}},"LCF"]

GraphData[{"SelfDual",{8,1}},"HamiltonianCycleCount"]

GraphData[{"SelfDual",{8,1}},"LCFSignature"]

GraphData[{"SelfDual",{8,1}},"LCFNotations"]

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

UnitDistance

GraphData[{"SelfDual",{8,1}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"SelfDual",{8,1}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"SelfDual",{8,1}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SelfDual",{8,1}},"Polyhedral"]

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

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

3D Canonical

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

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

3D Canonical construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 2}}

GraphData[{"SelfDual",{8,2}},"#"]

Primary

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

All

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

Planar

GraphData[{"SelfDual",{8,2}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction 5 around a square

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,2}},"Edges"]],2Pi/5]

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

RecognizeGraph@g

RectilinearCrossingCount@g

Tutte embedding construction 5

GraphPlot[RotateGraph[,-4Pi/5]]

h=v[[4,2]]//FullSimplify

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

RecognizeGraph[g]

Tutte embedding construction 4

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #3

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circular

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,2}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,2}},"Edges"]]

3D default

Graph3D[GraphData[{"SelfDual",{8,2}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 3}} == {"SelfComplementary", {8, 6}}

GraphData[{"SelfDual",{8,3}},"#"]

{"SelfDual", {8, 4}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{8,4}},{"CN","RCN"}]

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,4}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,4}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,4}},"Edges"]],2.5]

RotateGraph[LabelGraph@GraphicsToGraph@,Pi/2]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 5}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{8,5}},{"CN","RCN"}]

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,5}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,5}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,5}},"Edges"]],1.25]

RotateGraph[LabelGraph@GraphicsToGraph@,Pi/2]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 6}}

All

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

Circular

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,6}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,6}},"Edges"]]

MinimalCrossing

GraphData[{"SelfDual",{8,6}},{"CN","RCN"}]

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

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,6}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,6}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 7}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{8,7}},{"CN","RCN"}]

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,7}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,7}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,7}},"Edges"]],2.5]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 8}}

All

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

Circular

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

MinimalCrossing

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

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

UnitDistance

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,8}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,8}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,8}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 9}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{8,9}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{8,9}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,9}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,9}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,9}},"Edges"]],Pi/4]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,9}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 10}}

Primary

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

All

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

Planar

GraphData[{"SelfDual",{8,10}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@%

Tutte embedding pentagon on a square

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,10}},"Edges"]],1.25]

RotateGraph[LabelGraph@GraphicsToGraph@,-Pi/2]

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

RecognizeGraph@g

RectilinearCrossingCount@g

Tutte embedding construction 5

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

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

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

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

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

RecognizeGraph[g]

Tutte embedding construction 3 #3

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circular

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

UnitDistance

GraphData[{"SelfDual",{8,10}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,10}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,10}},"Edges"]]

3D default

Graph3D[GraphData[{"SelfDual",{8,10}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 11}} == {"Wheel", 8}

GraphData[{"SelfDual",{8,11}},"StandardName"]

{"SelfDual", {8, 12}}

All

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

Circular

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

UnitDistance

GraphData[{"SelfDual",{8,12}},"UnitDistance"]

MinimalCrossing

GraphData[{"SelfDual",{8,12}},{"CN","RCN"}]

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,12}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,12}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,12}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,12}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 13}}

All

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

Circular

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

UnitDistance

GraphData[{"SelfDual",{8,13}},"UnitDistance"]

MinimalCrossing

GraphData[{"SelfDual",{8,13}},{"CN","RCN"}]

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,13}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,13}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,13}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,13}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 14}}

All

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

Circular

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

UnitDistance

GraphData[{"SelfDual",{8,14}},"UnitDistance"]

MinimalCrossing

GraphData[{"SelfDual",{8,14}},{"CN","RCN"}]

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,14}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,14}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,14}},"Edges"]],.55]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{8,14}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {8, 15}}

Names

GraphData[{"SelfDual",{8,15}},"StandardName"]

GraphData[{"SelfDual",{8,15}},"StandardNames"]

Primary

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

All

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{8,15}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{8,15}},"Edges"]]

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

RecognizeGraph@g

RectilinearCrossingCount@g

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SelfDual",{8,15}},"Hamiltonian"]

GraphData[{"SelfDual",{8,15}},"LCF"]

GraphData[{"SelfDual",{8,15}},"HamiltonianCycleCount"]

Length[hc=FindHamiltonianCycle[GraphData[{"SelfDual",{8,15}}],All][[All,All,1]]]//Timing

(circ=CircularEmbeddingFromHamiltonianCycle[GraphData[{"SelfDual",{8,15}}],#]&/@hc);//Timing

graphswithsymmetrygroups={#,GraphSymmetryGroup[#]}&/@circ;//Timing

Tally[graphswithsymmetrygroups[[All,-1]]]//Column

(bilaterallyrotatedgraphs={BilaterallyRotatedGraph[#,"ReturnNonbilateralGraph"->True],#2}&@@@SortBy[
DeleteCases[graphswithsymmetrygroups,{_,TransformationGroup[{}]}],
{MatchQ[#[[2]],TransformationGroup[{_Rotation,r_Reflection}|{r_Reflection|_Rotation}]],FirstCase[#[[2]],Rotation[{0,0},r_]:>N[r/π],{},{0,∞}]}&
])//Timing

Length[symmetricgraphs=DeleteDuplicatesBy[bilaterallyrotatedgraphs,CircularCanonicalGraphEmbedding[#[[1]]]&]]//Timing

symmetricgraphs

gs=symmetricgraphs[[All,1]]

Planar

GraphData[{"SelfDual",{8,15}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

Tutte embedding construction 4 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4 #2

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[,2Pi/3]]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"SelfDual",{8,15}},{"CN","RCN"}]

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

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{8,15}},"Edges"]],Pi/4]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

UnitDistance

GraphData[{"SelfDual",{8,15}},"UnitDistance"]

3D default

Graph3D[GraphData[{"SelfDual",{8,15}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

9

GraphData["SelfDual",9]

{"SelfDual", {9, 1}}

All

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

Circular

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

UnitDistance

GraphData[{"SelfDual",{9,1}},"UnitDistance"]

MinimalCrossing

GraphData[{"SelfDual",{9,1}},{"CN","RCN"}]

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,1}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,1}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,1}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,1}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,1}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,1}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,1}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 2}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,2}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,2}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,2}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,2}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,2}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,2}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,2}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,2}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,2}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 3}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,3}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,3}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,3}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,3}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,3}},"Edges"]],.5]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,3}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,3}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,3}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,3}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 4}}

All

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

Planar

GraphData[{"SelfDual",{9,4}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction 6 around a square

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,4}},"Edges"]],.5]

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

RecognizeGraph@g

RectilinearCrossingCount@g

Tutte embedding construction 6

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #3

GraphPlot[RotateGraph[]]

v=Join[UnitCirclePoints[3],CirclePoints[1/4,3]];
v=Join[v,{{0,0}},Table[v[[6]]+i(v[[4]]-v[[6]])/3,{i,2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,1,4,5,6,8,9,4],e[6,3,5,9,7,5,2],{7,8}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Circular

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

UnitDistance

GraphData[{"SelfDual",{9,4}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,4}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,4}},"Edges"]]

3D default

Graph3D[GraphData[{"SelfDual",{9,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,4}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 5}}

Primary

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

All

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

Planar

GraphData[{"SelfDual",{9,5}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction 5 around square

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,5}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circular

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

UnitDistance

GraphData[{"SelfDual",{9,5}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,5}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,5}},"Edges"]]

3D default

Graph3D[GraphData[{"SelfDual",{9,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,5}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 6}}

Primary

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

All

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

Planar

GraphData[{"SelfDual",{9,6}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction  6 around square

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,6}},"Edges"]],.5]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

Tutte embedding construction 6

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[,2Pi/3]]

v=Join[UnitCirclePoints[3],CirclePoints[1/4,3]];
v=Join[v,Table[v[[6]]+i(v[[4]]-v[[6]])/3,{i,2}],{{0,1/16}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,1,5,3,6,7,8,4,1],e[6,5,4],e[7,9,8],e[2,5,9]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Tutte embedding construction 3 #3

GraphPlot[RotateGraph[,2Pi/3]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #4

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

v=Join[UnitCirclePoints[3],CirclePoints[1/4,3],{{0,0}}];
v=Join[v,Table[v[[6]]+i(v[[4]]-v[[6]])/3,{i,2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,1,4,5,6,3],e[6,8,9,4],e[2,5,7,8,5],e[7,9,5]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Circular

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

UnitDistance

GraphData[{"SelfDual",{9,6}},"UnitDistance"]

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

GraphData[{"SelfDual",{9,6}},"Graph","UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,6}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,6}},"Edges"]]

3D default

Graph3D[GraphData[{"SelfDual",{9,6}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 7}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,7}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,7}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,7}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,7}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,7}},"Edges"]],1.2]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,7}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 8}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,8}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,8}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,8}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,8}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,8}},"Edges"]],1.2]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,8}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

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

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

3D Polyhedron construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 9}}

All

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

Circular

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

MinimalCrossing

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

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

UnitDistance

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

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,9}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,9}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,9}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,9}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,9}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,9}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 10}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,10}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,10}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,10}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,10}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,10}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,10}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,10}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,10}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,10}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 11}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,11}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,11}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,11}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,11}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,11}},"Edges"]],0]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,11}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,11}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,11}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,11}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 12}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,12}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,12}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,12}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,12}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,12}},"Edges"]],.5]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,12}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,12}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,12}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,12}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 13}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,13}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,13}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,13}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,13}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,13}},"Edges"]],1.25]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,13}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,13}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,13}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,13}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 14}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,14}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,14}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,14}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,14}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,14}},"Edges"]],1.25]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,14}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,14}},"Graph",{"3D","Canonical"}]

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

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,14}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 15}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,15}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,15}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,15}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,15}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,15}},"Edges"]],Pi/4]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,15}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,15}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,15}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,15}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 16}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,16}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,16}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,16}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,16}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,16}},"Edges"]],1.25]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,16}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,16}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,16}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,16}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 17}}

Primary

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

All

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

Planar

GraphData[{"SelfDual",{9,17}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction 4 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4 #2

GraphPlot[RotateGraph[]]

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,17}},"Edges"]],Pi/4]

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

RecognizeGraph@g

RectilinearCrossingCount@g

Tutte embedding construction 4 #3

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circular

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

UnitDistance

GraphData[{"SelfDual",{9,17}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,17}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,17}},"Edges"]]

3D default

Graph3D[GraphData[{"SelfDual",{9,17}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,17}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,17}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,17}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 18}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,18}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,18}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,18}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,18}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,18}},"Edges"]],1.2]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,18}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,18}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,18}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,18}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 19}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,19}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,19}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,19}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,19}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,19}},"Edges"]],1.25]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,19}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,19}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,19}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,19}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 20}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,20}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,20}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,20}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,20}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,20}},"Edges"]],1.25]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,20}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,20}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,20}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,20}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 21}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,21}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,21}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,21}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,21}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,21}},"Edges"]],0]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,21}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,21}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,21}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,21}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 22}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,22}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,22}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,22}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,22}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,22}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,22}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,22}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,22}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,22}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 23}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,23}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,23}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,23}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,23}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,23}},"Edges"]],Pi/4]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,23}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,23}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,23}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,23}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 24}} == "GoddardHenningGraph"

GraphData[{"SelfDual",{9,24}},"#"]

{"SelfDual", {9, 25}}

GraphData[{"SelfDual",{9,25}},"#"]

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,25}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,25}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,25}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,25}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,25}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,25}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,25}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,25}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,25}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 26}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,26}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,26}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,26}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,26}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,26}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,26}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,26}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,26}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,26}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 27}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,27}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,27}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,27}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,27}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,27}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,27}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,27}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,27}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,27}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 28}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,28}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,28}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,28}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,28}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,28}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,28}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,28}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,28}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,28}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 29}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,29}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,29}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,29}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,29}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,29}},"Edges"]],1.55]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,29}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,29}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,29}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,29}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 30}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,30}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,30}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,30}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,30}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,30}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,30}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,30}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,30}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,30}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 31}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,31}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,31}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,31}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,31}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,31}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,31}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,31}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,31}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,31}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 32}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,32}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,32}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,32}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,32}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,32}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,32}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,32}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,32}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,32}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 33}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,33}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,33}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,33}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,33}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,33}},"Edges"]],Pi/4]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,33}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,33}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,33}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,33}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 34}}

Primary

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

All

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

Planar

GraphData[{"SelfDual",{9,34}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction 4 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4 #2

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4 #3

GraphPlot[RotateGraph[]]

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,34}},"Edges"]],Pi/4]

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

RecognizeGraph@g

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[,2Pi/3]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[,2Pi/3]]

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

RecognizeGraph[g]

Circular

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

UnitDistance

GraphData[{"SelfDual",{9,34}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,34}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,34}},"Edges"]]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,34}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,34}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,34}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,34}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 35}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,35}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,35}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,35}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,35}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,35}},"Edges"]],1.55]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,35}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,35}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,35}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,35}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 36}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,36}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,36}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,36}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,36}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,36}},"Edges"]],1.55]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,36}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,36}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,36}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,36}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 37}} == {"Wheel", 9}

GraphData[{"SelfDual",{9,37}},"#"]

{"SelfDual", {9, 38}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,38}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,38}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,38}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,38}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,38}},"Edges"]],1.55]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,38}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,38}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,38}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,38}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 39}}

Primary

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

All

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

Planar

GraphData[{"SelfDual",{9,39}},"Planar"]

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

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

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

RecognizeGraph/@gs

Tutte embedding construction 5 around a square

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,39}},"Edges"]],1.25]

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

RecognizeGraph@g

RectilinearCrossingCount@g

Tutte embedding construction 5

GraphPlot[RotateGraph[]]

{a,h}=v[[4]]//FullSimplify

v=Join[UnitCirclePoints[5]];
v=Join[v,{{0,h}},Table[Mean[{{0,h},v[[4]]}]+{0,i/9},{i,0,2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,5,1,6,5],e[2,6,7,4,9,3],e[7,8,9],{4,8},{3,6}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Tutte embedding construction 4

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #2

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 3 #3

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

v=Join[{{-1,0},{1,0},{0,Sqrt[3]},{-1/2,1/4},{0,1/4},{1/2,1/4}}];
v=Join[v,{Mean[v[[{3,6}]]]}];
v=Join[v,Table[v[[5]]+i/3(v[[7]]-v[[5]]),{i,2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,1,4,3,7,6,5,4],e[3,5,8,9,7],e[8,6,9],{2,6}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Circular

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

UnitDistance

GraphData[{"SelfDual",{9,39}},"UnitDistance"]

Default adjacency matrix

GraphPlot@AdjacencyGraph[GraphData[{"SelfDual",{9,39}},"AdjacencyMatrix"]]

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

RecognizeGraph@g

RectilinearCrossingCount@g

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,39}},"Edges"]]

3D default

Graph3D[GraphData[{"SelfDual",{9,39}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,39}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,39}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,39}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 40}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,40}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,40}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,40}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,40}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,40}},"Edges"]],1.55]

GraphicsToGraph@

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,40}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,40}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,40}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,40}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 41}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,41}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,41}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,41}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,41}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,41}},"Edges"]],.9]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,41}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,41}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,41}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,41}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 42}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,42}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,42}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,42}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,42}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,42}},"Edges"]],1.25]

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,42}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,42}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,42}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,42}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 43}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,43}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,43}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,43}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,43}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,43}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,43}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,43}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,43}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,43}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 44}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,44}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,44}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,44}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,44}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,44}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,44}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,44}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,44}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,44}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 45}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,45}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,45}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,45}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,45}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,45}},"Edges"]],Pi/4]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,45}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,45}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,45}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,45}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 46}} == {"JohnsonSkeleton", 8}

GraphData[{"SelfDual",{9,46}},"#"]

{"SelfDual", {9, 47}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,47}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,47}},"UnitDistance"]

Default adjacency matrix

GraphPlot@AdjacencyGraph[GraphData[{"SelfDual",{9,47}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,47}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,47}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,47}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,47}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,47}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,47}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 48}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,48}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,48}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,48}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,48}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,48}},"Edges"]],Pi/4]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,48}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,48}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,48}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,48}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 49}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,49}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,49}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,49}},"AdjacencyMatrix"]]

Default edges

GraphPlot@RotateGraph[Graph[GraphData[{"SelfDual",{9,49}},"Edges"]],-Pi/2]

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

RecognizeGraph@g

RectilinearCrossingCount@g

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,49}},"Edges"]],3.75]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,49}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,49}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,49}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,49}}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

{"SelfDual", {9, 50}}

All

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

Circular

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

MinimalCrossing

GraphData[{"SelfDual",{9,50}},{"CN","RCN"}]

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

UnitDistance

GraphData[{"SelfDual",{9,50}},"UnitDistance"]

Default adjacency matrix

AdjacencyGraph[GraphData[{"SelfDual",{9,50}},"AdjacencyMatrix"]]

Default edges

GraphPlot@Graph[GraphData[{"SelfDual",{9,50}},"Edges"]]

MinimalCrossing construction

GraphPlot@RotateGraph[PlanarGraph[GraphData[{"SelfDual",{9,50}},"Edges"]],1.25]

LabelGraph@GraphicsToGraph@

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

RecognizeGraph@g

RectilinearCrossingCount@g

3D default

Graph3D[GraphData[{"SelfDual",{9,50}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

3D Canonical

GraphData[{"SelfDual",{9,50}},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"SelfDual",{9,50}},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"SelfDual",{9,50}}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

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]

10

GraphData["SelfDual",10]

11

GraphData["SelfDual",11]

GraphData

<<MathWorld`Graphs`

file=OpenWrite["~/self-dual.m"]

WriteString[file,GraphDataString[CanonicalGraph[#2],
"Embeddings"->{},
"Name"->"("<>StringRiffle[ToString/@#,","]<>")\[Hyphen]self dual graph",
"StandardName"->{"SelfDual",#},
"Information"->"Self-DualGraph",
"Classes"->{"SelfDual"},
"NotationRules"->{"SelfDual"->#},
Debug->True,
TimeConstraint->60
]]&@@@new