Tutte 8-Cage

Author

Eric W. Weisstein
December 13, 2023

This notebook downloaded from http://mathworld.wolfram.com/notebooks/GraphTheory/Tutte8-Cage.nb.

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

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

Diagram construction

V5

LeviGraphConstruction2:=Module[{i,c=CircularVertices[10]},MakeUndirected[AddEdges[GraphUnion[AddEdges[AddEdges[GraphUnion[Cycle[10],EmptyGraph[10]],Table[{i,i+10},{i,10}]],Table[{i+10,i+15},{i,5}]],MakeGraph[Range[10],(Mod[#1-#2,10]==3)&]],Table[{10+i,20+i},{i,10}]]/.Graph[a_List,v_List]:>Graph[a,Join[2c,1.5c,c]]]]

lv1=AddEdges[
AddEdges[GraphUnion[Cycle[10],EmptyGraph[10]],
Table[{i,i+10},{i,10}]],
Table[{i+10,i+15},{i,5}]
]/.Graph[a_List,v_List]:>Graph[a,Join[2CircularVertices[10],CircularVertices[10]]];

lv2=AddEdges[GraphUnion[MakeGraph[Range[10],(Mod[#1-#2,10]==3)&],EmptyGraph[10]] /.Graph[a_List,v_List]:>Graph[a,Join[.7CircularVertices[10],CircularVertices[10]]],Table[{i,i+10},{i,10}]];

Show[GraphicsArray[{
Graphics[{
PointSize[.04],graphic[lv1],
Table[Text[Subscript[v,i],{Cos[#],.1+Sin[#]}&[2Pi i/10]],{i,10}]
},AspectRatio->Automatic],
Graphics[{
PointSize[.04],graphic[lv2],
Table[Text[Subscript[v,i],{Cos[#],.1+Sin[#]}&[2Pi i/10]],{i,10}]
},AspectRatio->Automatic],
Graphics[{
PointSize[.04],graphic[LeviGraph]
},AspectRatio->Automatic]
}]
]

New

es={
Partition[Range[21,30],2,1,1],
Flatten[Table[{10i+j,10i+j+10},{i,0,1},{j,10}],1],
Table[{i,i+5},{i,11,15}],
Partition[{1,4,7,10,3,6,9,2,5,8},2,1,1]};

v=Join@@Table[CirclePoints[i/4,10],{i,2,4}];
Graph[Range[Length[v]],UndirectedEdge@@@#,VertexCoordinates->v,VertexLabels->Automatic]&/@es

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

Configuration

GraphData["Tutte8Cage","Incidence"]

lines=GraphData["Tutte8Cage","Configurations"]

Subscript@@Reverse@Flatten@Tally[Length/@lines[[1]]]

RecognizeGraph[LeviGraph[#]]&/@lines

GraphData["CremonaRichmondConfigurationGraph","#"]

configg=GraphData["CremonaRichmondConfigurationGraph","Graph",{"Configuration","Labeled"}][[1]]

lines2=Sort@ConfigurationLinesFromGraph[configg]

LeviGraph[lines2]//RecognizeGraph

points=GraphEmbedding[configg]

ResourceFunction["FindExtraordinaryLines"][points]==lines2

ConfigurationGraph[points,lines2,VertexLabels->Automatic]

RecognizeGraph@%

ConfigurationDiagram[points,lines2,.3]

Embeddings

<<MathWorld`Graphs`

GraphData["Tutte8Cage","StandardName"]

GraphData["Tutte8Cage","AlternateStandardNames"]

Primary

GraphData["Tutte8Cage"]//StyleGraphs[#,ImageSize->Small]&

Read and Wilson construction

All

GraphData["Tutte8Cage","Graph","All"]//StyleGraphs

Inexact

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

Non-UnitDistance

Pick[
GraphData["Tutte8Cage","Graph","All"],
FreeQ[#,"UnitDistance"]&/@GraphData["Tutte8Cage","EmbeddingClasses"]]//StyleGraphs

Default embedding

GraphPlot@GraphData["Tutte8Cage","Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData["Tutte8Cage","Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData["Tutte8Cage","Graph","Bilateral"]//StyleGraphs

Circular

GraphData["Tutte8Cage","Graph","Circular"]//StyleGraphs

IntegerCoordinates

GraphData["Tutte8Cage","Graph","IntegerCoordinates"]//StyleGraphs

Integral = UnitDistance

Circulant

GraphData["Tutte8Cage","Circulant"]

GraphData["Tutte8Cage","Graph","Circulant"]//StyleGraphs

Halin

GraphData["Tutte8Cage","Halin"]

GraphData["Tutte8Cage","Graph","Halin"]//StyleGraphs

LCF

GraphData["Tutte8Cage","LCF"]

GraphData["Tutte8Cage","HamiltonianCycleCount"]

GraphData["Tutte8Cage","LCFSignature"]

GraphData["Tutte8Cage","Graph","LCF"]//StyleGraphs

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

LCF compute

Length[FindHamiltonianCycle[GraphData["Tutte8Cage"],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData["Tutte8Cage"],All])[[All,2]]]//Timing

LCFGraph@@@lcf//StyleGraphs

gs=Flatten[{
(* all LCF's with order >1, sorted by order and with bilateral graphs first *)
Join[DeleteCases[#,{_Missing,_}][[All,1]],Cases[#,{_Missing,_}][[All,2]]]&/@Map[{BilateralLCFEmbedding[#],#}&,Map[LCFGraph@@#&,SplitBy[DeleteCases[lcf,{_,1}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,1}]]}]

UnitDistance

GraphData["Tutte8Cage","UnitDistance"]

UnitDistanceGraphQ[GraphData["Tutte8Cage"],Debug->True]//Timing

GraphData["Tutte8Cage","Graph","UnitDistance"]//StyleGraphs

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

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

FindUnitDistanceEmbedding[GraphData["Tutte8Cage"],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

UnitDistance FindSubgraphUnitDistanceEmbedding

{"Tutte8Cage",FindSubgraphUnitDistanceEmbedding[GraphData["Tutte8Cage"],"Results"->All,TimeConstraint->300,Debug->Full]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData["Tutte8Cage","Graph","Matchstick"]//StyleGraphs

MinimalCrossing

GraphData["Tutte8Cage",{"RCN","CN"}]

GraphData["Tutte8Cage","Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData["Tutte8Cage"],"CrossingNumber"->13]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData["Tutte8Cage","Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

Properties

CrossingNumber

GraphData["Tutte8Cage","CrossingNumber"]

ExportString[GraphData["Tutte8Cage","EdgeRules"],"Graphlet"]

Dear Eric Weisstein,

we are sorry to report that the requested computation (Levi graph) failed.
Please contact Markus Chimani (http://www-lehre.informatik.uni-osnabrueck.de/theoinf/index/staff/chimani)
if you really need to compute the crossing number of this graph.

Please visit this link for detailed results: http://crossings.uos.de/job/JtLoK2uOAxOM9qkpWFGcVQ

Construction

Boben et al. as Levi graph of Cremona-Richmond

Boben, M.; Grünbaum, B.; Pisanski, T.; and Zitnik.  "Small Triangle-Free Configurations of Points and Lines."  Disc. Comput. Geom. 35, 405–427, 2006.

https://link.springer.com/content/pdf/10.1007/s00454-005-1224-9.pdf?pdf=button

g=LabelGraph@CenterGraph@GraphData["Tutte8Cage","Graph",2]

v=GraphEmbedding@g

groups=Split[Sort[Norm/@v],Abs[#1-#2]<.1&]

Length/@groups

{a,b}=Mean/@groups

a/b

v=Join[CirclePoints[20],CirclePoints[3/10,10]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,20},1,8],e[30,23,28,21,26,29,24,27,22,25,30],{17,4},{20,13},{16,9},{12,5},{19,30},{18,29},{15,28},{14,27},{11,26},{10,25},{7,24},{6,23},{2,21},{3,22}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

Union degenerate embedding

Not this one:

v=Join@@Table[CirclePoints[i/4,10],{i,2,4}];
es={
Partition[Range[21,30],2,1,1],
Sequence@@Partition[#,2,1,1]&/@Table[i+10j,{i,10},{j,0,2}],
Table[{i,i+5},{i,5}],Partition[{1,4,7,10,3,6,9,2,5,8},2,1,1]
};
Graph[Range[Length[v]],UndirectedEdge@@@#,VertexCoordinates->v,VertexLabels->Automatic]&/@es

Graph[Range[Length[v]],UndirectedEdge@@@Join@@es,VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

This one:

es={
Partition[Range[21,30],2,1,1],
Flatten[Table[{10i+j,10i+j+10},{i,0,1},{j,10}],1],
Table[{i,i+5},{i,11,15}],
Partition[{1,4,7,10,3,6,9,2,5,8},2,1,1]};

v=Join@@Table[CirclePoints[i/4,10],{i,2,4}];
Graph[Range[Length[v]],UndirectedEdge@@@#,VertexCoordinates->v,VertexLabels->Automatic]&/@es

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

RecognizeGraph[g]

MinimalRectilinearCrossing

Show[ImageCrop@Import["http://isu.indstate.edu/ge/COMBIN/RECTILINEAR/tutte.png"],ImageSize->Small]

distanceregular.org

g=DistanceRegularGraph["http://www.distanceregular.org/graphdata/tutte8.am"]

RecognizeGraph[g]

VertexCount[g]

GraphDiameter[g]//Timing

RegularParameters[g]//Timing

DistanceRegularGraphQ[g]//Timing

IntersectionArray[g]//Timing

IntegerSpectrum[g]//SpectrumForm

GroupOrder[GraphAutomorphismGroup[g]]

HamiltonianGraphQ[g]

UnitDistance 1 (Gerbracht) [4 graphs; need exact coordinates]

W01={0,5/4};
W03=FullSimplify[{Re[(W01[[1]]+I*W01[[2]])Exp[I*1(2Pi)/5]],Im[(W01[[1]]+I*W01[[2]])Exp[I*1(2Pi)/5]]}];
W05=FullSimplify[{Re[(W01[[1]]+I*W01[[2]])Exp[I*2(2Pi)/5]],Im[(W01[[1]]+I*W01[[2]])Exp[I*2(2Pi)/5]]}];
W07=FullSimplify[{Re[(W01[[1]]+I*W01[[2]])Exp[I*3(2Pi)/5]],Im[(W01[[1]]+I*W01[[2]])Exp[I*3(2Pi)/5]]}];
W09=FullSimplify[{Re[(W01[[1]]+I*W01[[2]])Exp[I*4(2Pi)/5]],Im[(W01[[1]]+I*W01[[2]])Exp[I*4(2Pi)/5]]}];

P01=(W01[[1]]-xW2)^2+(W01[[2]]-yW2)^2-1;
P02=(W03[[1]]-xW2)^2+(W03[[2]]-yW2)^2-1;
SW=FullSimplify[Solve[{P01,P02}==0,{xW2,yW2}]];

W02=FullSimplify[{xW2,yW2}/.SW[[2]]];
W04=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*1(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*1(2Pi)/5]]}];
W06=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*2(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*2(2Pi)/5]]}];
W08=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*3(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*3(2Pi)/5]]}];
W10=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*4(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*4(2Pi)/5]]}];

xU2=0;
xU7=0;
P03=(xV2-xU2)^2+(yV2-yU2)^2-1;
P04=(xV2-W02[[1]])^2+(yV2-W02[[2]])^2-1;
P05=(xV2-xV7)^2+(yV2-yV7)^2-1;
P06=(xV7-W07[[1]])^2+(yV7-W07[[2]])^2-1;
P07=(xV7-xU7)^2+(yV7-yU7)^2-1;
P08=xU9^2+yU9^2-yU7^2;
P09=(yU7/Sin[(Pi-2Pi/5)/2]Sin[2Pi/5])^2-(xU9-xU7)^2-(yU9-yU7)^2;
P10=(xU2-xU9)^2+(yU2-yU9)^2-1;

eqn=Thread[{P03,P04,P05,P06,P07,P08,P09,P10}==0]

vars=Variables[Subtract@@@eqn]

Length[nsoln1=NSolve[eqn,vars,Reals,WorkingPrecision->20]]//Timing

Use FindRoot starting with individual solutions to get this much faster:

Length[nsoln1=NSolve[
Thread[{P03,P04,P05,P06,P07,P08,P09,P10}==0],
{yU2,yU7,xU9,yU9,xV2,yV2,xV7,yV7},
Reals,
WorkingPrecision->21000
]]//Timing

Length[nsoln1=NSolve[
Thread[{P03,P04,P05,P06,P07,P08,P09,P10}==0],
{yU2,yU7,xU9,yU9,xV2,yV2,xV7,yV7},
Reals,
WorkingPrecision->31000
]]//Timing

soln1=Solve[
Thread[{P03,P04,P05,P06,P07,P08,P09,P10}==0],
{yU2,yU7,xU9,yU9,xV2,yV2,xV7,yV7},
Reals
];//Timing

...hangs/runs for a long time...

LeviUD[solns_]:=Module[{},
(
U02={xU2,yU2}/.#;
U07={xU7,yU7}/.#;
V02={xV2,yV2}/.#;
V07={xV7,yV7}/.#;U04=FullSimplify[{Re[(U02[[1]]+I*U02[[2]])Exp[I*1(2Pi)/5]],Im[(U02[[1]]+I*U02[[2]])Exp[I*1(2Pi)/5]]}];
U06=FullSimplify[{Re[(U02[[1]]+I*U02[[2]])Exp[I*2(2Pi)/5]],Im[(U02[[1]]+I*U02[[2]])Exp[I*2(2Pi)/5]]}];
U08=FullSimplify[{Re[(U02[[1]]+I*U02[[2]])Exp[I*3(2Pi)/5]],Im[(U02[[1]]+I*U02[[2]])Exp[I*3(2Pi)/5]]}];
U10=FullSimplify[{Re[(U02[[1]]+I*U02[[2]])Exp[I*4(2Pi)/5]],Im[(U02[[1]]+I*U02[[2]])Exp[I*4(2Pi)/5]]}];U09=FullSimplify[{Re[(U07[[1]]+I*U07[[2]])Exp[I*1(2Pi)/5]],Im[(U07[[1]]+I*U07[[2]])Exp[I*1(2Pi)/5]]}];
U01=FullSimplify[{Re[(U07[[1]]+I*U07[[2]])Exp[I*2(2Pi)/5]],Im[(U07[[1]]+I*U07[[2]])Exp[I*2(2Pi)/5]]}];
U03=FullSimplify[{Re[(U07[[1]]+I*U07[[2]])Exp[I*3(2Pi)/5]],Im[(U07[[1]]+I*U07[[2]])Exp[I*3(2Pi)/5]]}];
U05=FullSimplify[{Re[(U07[[1]]+I*U07[[2]])Exp[I*4(2Pi)/5]],Im[(U07[[1]]+I*U07[[2]])Exp[I*4(2Pi)/5]]}];V04=FullSimplify[{Re[(V02[[1]]+I*V02[[2]])Exp[I*1(2Pi)/5]],Im[(V02[[1]]+I*V02[[2]])Exp[I*1(2Pi)/5]]}];
V06=FullSimplify[{Re[(V02[[1]]+I*V02[[2]])Exp[I*2(2Pi)/5]],Im[(V02[[1]]+I*V02[[2]])Exp[I*2(2Pi)/5]]}];
V08=FullSimplify[{Re[(V02[[1]]+I*V02[[2]])Exp[I*3(2Pi)/5]],Im[(V02[[1]]+I*V02[[2]])Exp[I*3(2Pi)/5]]}];
V10=FullSimplify[{Re[(V02[[1]]+I*V02[[2]])Exp[I*4(2Pi)/5]],Im[(V02[[1]]+I*V02[[2]])Exp[I*4(2Pi)/5]]}];V09=FullSimplify[{Re[(V07[[1]]+I*V07[[2]])Exp[I*1(2Pi)/5]],Im[(V07[[1]]+I*V07[[2]])Exp[I*1(2Pi)/5]]}];
V01=FullSimplify[{Re[(V07[[1]]+I*V07[[2]])Exp[I*2(2Pi)/5]],Im[(V07[[1]]+I*V07[[2]])Exp[I*2(2Pi)/5]]}];
V03=FullSimplify[{Re[(V07[[1]]+I*V07[[2]])Exp[I*3(2Pi)/5]],Im[(V07[[1]]+I*V07[[2]])Exp[I*3(2Pi)/5]]}];
V05=FullSimplify[{Re[(V07[[1]]+I*V07[[2]])Exp[I*4(2Pi)/5]],Im[(V07[[1]]+I*V07[[2]])Exp[I*4(2Pi)/5]]}];
v=ToExpression[Flatten[Outer[StringJoin,{"U","V","W"},(If[#<10,"0",""]<>ToString[#])&/@Range[10]]]];
e=UnitEdges[v];
Graph[Range[30],UndirectedEdge@@@e,VertexCoordinates->v])&/@solns
]

LeviUD[nsoln1]

RecognizeGraph/@%

gs1=RotateGraph[#,Pi]&/@Take[LeviUD[nsoln1],4]

Precision[GraphEmbedding[gs1[[1]]][[1,1]]]

Abs[EdgeLengths[gs1[[1]]]-1]//Max

UnitDistance 2 (Gerbracht) [6 graphs; need exact coordinates]

Need above definitions as well...

W02=FullSimplify[{xW2,yW2}/.SW[[1]]];
W04=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*1(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*1(2Pi)/5]]}];
W06=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*2(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*2(2Pi)/5]]}];
W08=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*3(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*3(2Pi)/5]]}];
W10=FullSimplify[{Re[(W02[[1]]+I*W02[[2]])Exp[I*4(2Pi)/5]],Im[(W02[[1]]+I*W02[[2]])Exp[I*4(2Pi)/5]]}];

xU2=0;
xU7=0;

P03=(xV2-xU2)^2+(yV2-yU2)^2-1;
P04=(xV2-W02[[1]])^2+(yV2-W02[[2]])^2-1;
P05=(xV2-xV7)^2+(yV2-yV7)^2-1;
P06=(xV7-W07[[1]])^2+(yV7-W07[[2]])^2-1;
P07=(xV7-xU7)^2+(yV7-yU7)^2-1;
P08=xU9^2+yU9^2-yU7^2;
P09=(yU7/Sin[(Pi-(2*Pi)/5)/2]*Sin[2*Pi/5])^2-(xU9-xU7)^2-(yU9-yU7)^2;
P10=(xU2-xU9)^2+(yU2-yU9)^2-1;

eqn=Thread[{P03,P04,P05,P06,P07,P08,P09,P10}==0]

vars=Variables[Subtract@@@eqn]

Length[nsoln2=NSolve[eqn,vars,Reals,WorkingPrecision->20]]//Timing

Use FindRoot starting with individual solutions to get this much faster:

Length[nsoln=NSolve[
Thread[{P03,P04,P05,P06,P07,P08,P09,P10}==0],
{yU2,yU7,xU9,yU9,xV2,yV2,xV7,yV7},
Reals,WorkingPrecision->21000]]//Timing

Length[nsoln=NSolve[
Thread[{P03,P04,P05,P06,P07,P08,P09,P10}==0],
{yU2,yU7,xU9,yU9,xV2,yV2,xV7,yV7},
Reals,WorkingPrecision->31000]]//Timing

LeviUD[nsoln2]

RecognizeGraph/@LeviUD[nsoln]

gs2=LeviUD[nsoln][[{1,2,6,11,8,9}]]

Precision[GraphEmbedding[gs2[[1]]][[1,1]]]

Abs[EdgeLengths[gs2[[1]]]-1]//Max

UnitDistance Folding (Gerbracht)

Approximate coordinates from Gerbracht's diagram

Import["/Users/eww/Levi_fold.pdf"]

g=;

pts=Cases[g,HoldPattern[BezierCurve[x_,SplineClosed->True,SplineDegree->3]]:>Mean[x],{1,∞}]

Length[pts]

V[Graph["Tutte8Cage"]]

Graphics[{{Red,PointSize[.02],Point[pts]},MapIndexed[Text[#2[[1]],#1+10]&,pts]},Axes->True]

s=Norm[Subtract@@pts[[{15,16}]]]

pts2=Delete[pts,{1}]/s

Length[pts2]

Graphics[{{Red,PointSize[.02],Point[pts2]},MapIndexed[Text[#2[[1]],#1+.1]&,pts2]},Axes->True]

Norm[Subtract@@pts2[[{14,15}]]]

e=Select[Subsets[Range[30],{2}],.995<Norm[Subtract@@pts2[[#]]]<1.005&]

Length[%]

GraphData["Tutte8Cage","M"]

ShowLabeledGraph[g=Graph[List/@e,List/@pts2],VertexStyle->Disk[.02],EdgeStyle->Thickness[.001]]

ShowLabeledGraph[g2=DeleteEdges[g,{{7,18},{20,26},{27,5},{28,6},{25,3},{24,2},{23,1},{22,10},{21,9},{30,8},{29,7},{4,26}}],VertexStyle->Disk[.02],EdgeStyle->Thickness[.001],ImageSize->500]

Degrees[g2]

Position[%,4]//Flatten

Edges[g2]//Length

RecognizeGraph[g2]

Norm[Subtract@@pts2[[#]]]&/@e

ToCommonEdges[g2,"Tutte8Cage"]

GraphPlot[g2,Method->None,ImageSize->200]

Exact

Show[g0=GraphData["Tutte8Cage","Graph",{"Labeled","UnitDistance"}][[-1]],Axes->True]

Abs[EdgeLengths[g0]-1]

Show[g1=TranslateGraph[g0,Mean[GraphEmbedding[g0][[Complement[Range[30],{2,3,24,25,8,9,10,17,18,19}]]]]],Axes->True]

v1=GraphEmbedding[g1]

Norm/@v1

(groups=(SortBy[#,#[[2]]&]&/@SplitBy[SortBy[MapIndexed[{Round[10^2Norm[#]],Mod[ArcTan@@#,2Pi],#2[[1]]}&,v1],First],First])[[All,All,3]])//Column

Norm/@v1[[{30,22}]]

HighlightGraph[g,#,ImageSize->300]&/@Take[groups,2]

Core

Looks like inner circle is rotated Pi/10, but not quite:

v=Join[
CirclePoints[{1/2,0},10],
CirclePoints[{(1/2) (-1+(Sqrt[5])),Pi/10},10]
];
g=Graph[Range[Length[v]],UnitEdges[v],VertexCoordinates->v,VertexLabels->Automatic]

Find the actual rotation angle of the inner circle:

v=Join[
CirclePoints[{1/2,0},10],
CirclePoints[{(1/2) (-1+(Sqrt[5])),q},10]
];

eqn=FullSimplify[SquaredEuclideanDistance@@v[[{9,12}]]-1/.Abs->Identity]

soln=Solve[eqn==0&&0<q<1/2,q]//FullSimplify

N[{Pi/10,q/.soln[[1]]}]

v=Join[
CirclePoints[{1/2,0},10],
CirclePoints[{(1/2) (-1+(Sqrt[5])),-(π/5)+2 ArcCot[(Sqrt[1+(2/(Sqrt[5]))+2 (Sqrt[-(18/5)+2 (Sqrt[5])])])]},10]
];

g=Graph[Range[Length[v]],UnitEdges[v],VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Quit

Exoo circular + offset

2019-05-08

data=ImportString["50,450,2,30,8
291,445,1,3,25
331,432,2,4,12
367,411,3,5,17
398,383,4,6,22
423,350,5,7,27
440,311,6,8,14
448,270,7,9,1
448,229,8,10,18
440,188,9,11,23
423,150,10,12,28
398,116,11,13,3
367,88,12,14,20
331,67,13,15,7
291,54,14,16,24
250,50,15,17,29
208,54,16,18,4
168,67,17,19,9
132,88,18,20,26
101,116,19,21,13
76,149,20,22,30
59,188,21,23,5
51,229,22,24,10
51,270,23,25,15
59,311,24,26,2
76,349,25,27,19
101,383,26,28,6
132,411,27,29,11
168,432,28,30,16
208,445,29,1,21","CSV"]

v=data[[All,;;2]];
e=Union[Sort/@Flatten[MapIndexed[Thread[#2[[1]]->Drop[#,2]]&,data]]]

g=Graph[Range[Length[v]],UndirectedEdge@@@e,VertexCoordinates->v]//StyleGraphs[#,VertexSize->{"Scaled",.02}]&

r=RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphData[r,"StandardNames"]

Levi graph of Cremona-Richmond configuration

GraphData["CremonaRichmondConfigurationGraph","Graph","Labeled"]

lines={{1,2,4},{1,6,11},{1,9,14},{2,5,12},{2,7,10},{3,5,9},{3,6,7},{3,4,13},{4,8,15},{5,11,15},{6,8,12},{7,14,15},{8,9,10},{10,11,13},{12,13,14}};

RecognizeGraph[LeviGraph[lines]]

GraphData

GraphClassString

GraphClassString["Tutte8Cage"]