Cameron Cubic Hamiltonian Graphs

Author

Eric W. Weisstein
May 7, 2026

This notebook downloaded from https://mathworld.wolfram.com/notebooks/GraphTheory/CameronCubicHamiltonianGraphs.nb.

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

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

Figures

GraphicsGrid[
Partition[Table[Annotate[CameronGraph[n,GraphLayout->"TwistedEmbedding"],PlotLabel->Style[Row[{Style["n",Italic],"==",n}," "],Directive[14,FontFamily->"Times"]]],{n,6}]//StyleGraphs,3],
Dividers->All,Alignment->Top,ItemAspectRatio->Automatic]

GraphicsGrid[Table[StyleGraphs[#,PlotLabel->Style[Row[{Style["n",Italic],"==",n}," "],Directive[14,FontFamily->"Times"]]]&/@GraphData[{"Cameron",n},"Graph","LCF"],{n,5}],Dividers->All]

Embeddings

<<MathWorld`Graphs`

{"Cameron", 1}

Names

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

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

Primary

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

Cameron construction

gs=Table[CameronGraph[1,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",1}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",1},"VertexList"],GraphData[{"Cameron",1},"Edges"]]]

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

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

HalinGraphEmbeddingQ[g]

RecognizeGraph[g]

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",1},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GeneralizedPetersen

GraphData[{"Cameron",1},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",1},"Graph","IGraph"]//StyleGraphs

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"Cameron",1},"Hamiltonian"]

GraphData[{"Cameron",1},"LCF"]

GraphData[{"Cameron",1},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",1},"Planar"]

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

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",1}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",1}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",1},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",1}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",1}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{BilaterallyRotatedGraph@CenterGraph@#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction 6

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4 #1

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Tutte embedding construction 4 #2

GraphPlot[RotateGraph[,Pi/2]]

RotateGraph[GraphicsToGraph@,Pi]

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

RecognizeGraph[g]

Tutte embedding construction 3

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

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",1},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",1},"RCN"]

GraphData[{"Cameron",1},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",1},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",1},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",1},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",1},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",1},"Circulant"]

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

Circulant construction

GraphData[{"Cameron",1},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",1}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",1},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",1},"ComplementGraph","Name"]

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"Cameron",1},"Line"]

LineGraphQ[GraphData[{"Cameron",1}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",1}&]

RootGraph[GraphData[{"Cameron",1}]]

Halin

GraphData[{"Cameron",1},"Halin"]

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

Rigid

GraphData[{"Cameron",1},"Rigid"]

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

Flexible

GraphData[{"Cameron",1},"Flexible"]

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

LCF

GraphData[{"Cameron",1},"LCF"]

GraphData[{"Cameron",1},"HamiltonianCycleCount"]

GraphData[{"Cameron",1},"LCFSignature"]

GraphData[{"Cameron",1},"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"Cameron",1},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",1}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",1}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",1},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

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

gs=UniqueEmbeddings[l]

gs={,,,};

Matchstick

GraphData[{"Cameron",1},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Cameron",1},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Cameron",1},"Polyhedral"]

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

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

3D Canonical

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

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

3D Polyhedron

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

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

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

3D Canonical construction

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

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//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]

3D Canonical construction from PolyhedralEmbedding

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

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

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

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

SimplePolyhedronQ[can]

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]

{"Cameron", 2}

Names

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

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

Cameron construction

<<MathWorld`Graphs`

gs=Table[CameronGraph[2,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",2}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",2},"VertexList"],GraphData[{"Cameron",2},"Edges"]]]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",2},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",2},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",2},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",2},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",2},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",2},"Graph","Bilateral"]//StyleGraphs

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

Circular

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

Circular construction

GraphData[{"Cameron",2},"Hamiltonian"]

GraphData[{"Cameron",2},"LCF"]

GraphData[{"Cameron",2},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",2},"Planar"]

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

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",2}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",2}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",2},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",2}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",2}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{BilaterallyRotatedGraph@CenterGraph@#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction 10

GraphPlot[]

v=CirclePoints[10];
v=Join[v,Subdivide[v[[8]],v[[3]],9][[2;;-2]]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph[g]

Tutte embedding construction 6

GraphPlot[]

v=Join[CirclePoints[6],Subdivide[{-1/2,0},{1/2,0},7]];
v=Join[v,Mean[v[[#]]]&/@{{4,7},{3,14}}];
v=Join[v,{v[[#,1]],v[[15,2]]}&/@{9,12}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph[g]

Tutte embedding construction 4

GraphPlot[]

v=Delete[Join[{{0,0},{5,0},{5,5},{0,5}},Tuples[Range[4],2]],List/@{10,14}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",2},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",2},"RCN"]

GraphData[{"Cameron",2},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",2},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",2},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",2},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",2},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",2},"Circulant"]

GraphData[{"Cameron",2},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",2},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",2}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",2},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",2},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",2},"Line"]

LineGraphQ[GraphData[{"Cameron",2}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",2}&]

RootGraph[GraphData[{"Cameron",2}]]

Halin

GraphData[{"Cameron",2},"Halin"]

GraphData[{"Cameron",2},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",2},"Rigid"]

GraphData[{"Cameron",2},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",2},"Flexible"]

GraphData[{"Cameron",2},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",2},"LCF"]

GraphData[{"Cameron",2},"HamiltonianCycleCount"]

GraphData[{"Cameron",2},"LCFSignature"]

GraphData[{"Cameron",2},"LCFNotations"]

GraphData[{"Cameron",2},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"Cameron",2},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",2}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",2}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",2},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",2}],Debug->True]//Timing

GraphData[{"Cameron",2},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",2},"VertexList"],GraphData[{"Cameron",2},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance construction

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

gs={,};

Matchstick

GraphData[{"Cameron",2},"Matchstick"]

GraphData[{"Cameron",2},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",2},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Cameron",2},"Polyhedral"]

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

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

3D Canonical

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

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

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",2},"Graph",2]

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

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

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

SimplePolyhedronQ[can]

can//Graphics3D

(can=FindCanonicalPolyhedron[can,WorkingPrecision->100,MaxIterations->10^5,PrecisionGoal->20,"ProgressInterval"->10^3,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//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]

{"Cameron", 3}

Names

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

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

Cameron construction

gs=Table[CameronGraph[3,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",3},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",3}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",3}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",3}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction 4

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",3},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",3},"RCN"]

GraphData[{"Cameron",3},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",3},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",3},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",3},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",3},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",3}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",3}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

LabelGraph@

g=LCFGraph[{-13,5,-3,6,4,2,-5,-2,-4,-6,-12,12,3},2,18]

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

gs={,};

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

GraphData[{"Cameron",3},"Graph",{"3D","Canonical"}]

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=;

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

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

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

can//Graphics3D

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 4}

Names

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

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

Cameron construction

gs=Table[CameronGraph[4,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

v=Delete[Flatten[Table[{i,j},{i,0,9},{j,0,3}],1],List/@{2,3,5,33,38,39}];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[1,6,10],e[22,26,33,34,32,29,25,21,17,13,9,5,2,1,3,4,5],{2,4},{31,34},e[6,7,8,9],e[10,11,12,13],e[14,15,16,17],e[18,19,20,21],e[22,23,24,25],e[26,27,28,29],e[27,30,31,32],{30,33},{3,7},e[11,14,18,23],{8,12},{16,20},{24,28},{10,15},{19,22}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",4},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",4}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

TextGrid[DeleteCases[{BilaterallyRotatedGraph@CenterGraph@#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",4},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",4},"RCN"]

GraphData[{"Cameron",4},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",4},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",4},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",4},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",4},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",4}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",4}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",4},"Graph","Planar"][[1]]

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

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 5}

Names

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

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

Cameron construction

gs=Table[CameronGraph[5,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",5},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",5}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[,VertexSize->{"Scaled",.01}]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",5},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",5},"RCN"]

GraphData[{"Cameron",5},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",5},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",5},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",5},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",5},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",5}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",5}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

g=LCFGraph[{-21,13,-3,14,12,6,4,2,5,-2,-4,-6,3,-5,-13,-3,-12,-14,-20,20,3},2,26]

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",5},"Graph","Planar"][[1]]

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

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 6}

Names

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

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

Cameron construction

gs=Table[CameronGraph[6,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",6},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",6}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",6},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",6},"RCN"]

GraphData[{"Cameron",6},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",6},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",6},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",6},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",6},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",6}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",6}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",6},"Graph","Planar"][[1]]

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

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 7}

Names

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

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

Cameron construction

gs=Table[CameronGraph[7,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",7},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",7}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

TextGrid[DeleteCases[{BilateralGraph@CenterGraph@#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",7},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",7},"RCN"]

GraphData[{"Cameron",7},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",7},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",7},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",7},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",7},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",7}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",7}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",7},"Graph","Planar"][[1]]

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

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 8}

Names

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

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

Cameron construction

gs=Table[CameronGraph[8,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",8},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",8}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

TextGrid[DeleteCases[{BilateralGraph@CenterGraph@#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",8},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",8},"RCN"]

GraphData[{"Cameron",8},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"Cameron",8}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"Cameron",8}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalCrossing construction

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Select[tuttegraphs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",8},"V"]])]==0&]

Select[tuttegraphs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",8},"V"]])]==1&]

(gs=Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Cameron",8}],"CrossingNumber"->cn,RandomSeed->n]],{n,1000}]//Union)//Timing

Select[gs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",8},"V"]])]==0&]

Select[gs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",8},"V"]])]==1&]

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Cameron",8},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",8},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",8},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",8},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",8}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",8}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

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

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

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 9}

Names

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

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

Cameron construction

gs=Table[CameronGraph[9,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",9},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",9}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

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

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",9},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",9},"RCN"]

GraphData[{"Cameron",9},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",9},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",9},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",9},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",9},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",9}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",9}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@Dlcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",9},"Graph","Planar"][[1]]

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

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 10}

Names

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

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

Cameron construction

gs=Table[CameronGraph[10,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

hogid=GraphData[{"Cameron",10},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",10}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

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

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",10}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

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

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

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

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",10},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"Cameron",10},"RCN"]

GraphData[{"Cameron",10},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",10},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",10},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",10},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"Cameron",10},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",10}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",10}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

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

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

3D Canonical construction

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",10},"Graph","Planar"][[1]]

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

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

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

SimplePolyhedronQ[can]

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

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

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

v=PolyhedronCoordinates[can];

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

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

g=PolyhedronGraph[can]

{"Cameron", 11}

Names

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

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

Cameron construction

gs=Table[CameronGraph[11,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",11},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",11},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",11},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",11},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",11},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",11},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",11},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",11},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",11},"Hamiltonian"]

GraphData[{"Cameron",11},"LCF"]

GraphData[{"Cameron",11},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",11},"Planar"]

GraphData[{"Cameron",11},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",11}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",11}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",11},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",11}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",11}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",11}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",11},"CN"]

GraphData[{"Cameron",11},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",11},"RCN"]

GraphData[{"Cameron",11},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",11},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",11},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",11},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",11},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",11},"Circulant"]

GraphData[{"Cameron",11},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",11},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",11}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",11},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",11},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",11},"Line"]

LineGraphQ[GraphData[{"Cameron",11}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",11}&]

RootGraph[GraphData[{"Cameron",11}]]

Halin

GraphData[{"Cameron",11},"Halin"]

GraphData[{"Cameron",11},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",11},"Rigid"]

GraphData[{"Cameron",11},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",11},"Flexible"]

GraphData[{"Cameron",11},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",11},"LCF"]

GraphData[{"Cameron",11},"HamiltonianCycleCount"]

GraphData[{"Cameron",11},"LCFSignature"]

GraphData[{"Cameron",11},"LCFNotations"]

GraphData[{"Cameron",11},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",11},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",11}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",11}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",11},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",11}],Debug->True]//Timing

GraphData[{"Cameron",11},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",11},"VertexList"],GraphData[{"Cameron",11},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",11},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",11}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",11}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",11},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",11}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",11},"Matchstick"]

GraphData[{"Cameron",11},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",11},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",11},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",11},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",11},"Polyhedral"]

GraphData[{"Cameron",11},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",11},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",11},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",11},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",11}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",11},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 12}

Names

GraphData[{"Cameron",12},"StandardName"]

GraphData[{"Cameron",12},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[12,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",12}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",12},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",12},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",12}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",12},"VertexList"],GraphData[{"Cameron",12},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",12},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",12},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",12},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",12},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",12},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",12},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",12},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",12},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",12},"Hamiltonian"]

GraphData[{"Cameron",12},"LCF"]

GraphData[{"Cameron",12},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",12},"Planar"]

GraphData[{"Cameron",12},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",12}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",12}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",12},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",12}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",12}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",12}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",12},"CN"]

GraphData[{"Cameron",12},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",12},"RCN"]

GraphData[{"Cameron",12},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",12},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",12},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",12},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",12},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",12},"Circulant"]

GraphData[{"Cameron",12},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",12},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",12}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",12},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",12},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",12},"Line"]

LineGraphQ[GraphData[{"Cameron",12}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",12}&]

RootGraph[GraphData[{"Cameron",12}]]

Halin

GraphData[{"Cameron",12},"Halin"]

GraphData[{"Cameron",12},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",12},"Rigid"]

GraphData[{"Cameron",12},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",12},"Flexible"]

GraphData[{"Cameron",12},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",12},"LCF"]

GraphData[{"Cameron",12},"HamiltonianCycleCount"]

GraphData[{"Cameron",12},"LCFSignature"]

GraphData[{"Cameron",12},"LCFNotations"]

GraphData[{"Cameron",12},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",12},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",12}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",12}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",12},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",12}],Debug->True]//Timing

GraphData[{"Cameron",12},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",12},"VertexList"],GraphData[{"Cameron",12},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",12},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",12}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",12}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",12},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",12}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",12},"Matchstick"]

GraphData[{"Cameron",12},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",12},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",12},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",12},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",12},"Polyhedral"]

GraphData[{"Cameron",12},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",12},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",12},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",12},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",12}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",12},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 13}

Names

GraphData[{"Cameron",13},"StandardName"]

GraphData[{"Cameron",13},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[13,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",13}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",13},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",13},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",13}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",13},"VertexList"],GraphData[{"Cameron",13},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",13},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",13},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",13},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",13},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",13},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",13},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",13},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",13},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",13},"Hamiltonian"]

GraphData[{"Cameron",13},"LCF"]

GraphData[{"Cameron",13},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",13},"Planar"]

GraphData[{"Cameron",13},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",13}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",13}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",13},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",13}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",13}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",13}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",13},"CN"]

GraphData[{"Cameron",13},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",13},"RCN"]

GraphData[{"Cameron",13},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",13},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",13},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",13},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",13},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",13},"Circulant"]

GraphData[{"Cameron",13},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",13},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",13}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",13},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",13},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",13},"Line"]

LineGraphQ[GraphData[{"Cameron",13}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",13}&]

RootGraph[GraphData[{"Cameron",13}]]

Halin

GraphData[{"Cameron",13},"Halin"]

GraphData[{"Cameron",13},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",13},"Rigid"]

GraphData[{"Cameron",13},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",13},"Flexible"]

GraphData[{"Cameron",13},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",13},"LCF"]

GraphData[{"Cameron",13},"HamiltonianCycleCount"]

GraphData[{"Cameron",13},"LCFSignature"]

GraphData[{"Cameron",13},"LCFNotations"]

GraphData[{"Cameron",13},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",13},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",13}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",13}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",13},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",13}],Debug->True]//Timing

GraphData[{"Cameron",13},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",13},"VertexList"],GraphData[{"Cameron",13},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",13},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",13}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",13}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",13},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",13}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",13},"Matchstick"]

GraphData[{"Cameron",13},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",13},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",13},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",13},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",13},"Polyhedral"]

GraphData[{"Cameron",13},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",13},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",13},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",13},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",13}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",13},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 14}

Names

GraphData[{"Cameron",14},"StandardName"]

GraphData[{"Cameron",14},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[14,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",14}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",14},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",14},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",14}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",14},"VertexList"],GraphData[{"Cameron",14},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",14},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",14},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",14},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",14},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",14},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",14},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",14},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",14},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",14},"Hamiltonian"]

GraphData[{"Cameron",14},"LCF"]

GraphData[{"Cameron",14},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",14},"Planar"]

GraphData[{"Cameron",14},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",14}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",14}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",14},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",14}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",14}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",14}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",14},"CN"]

GraphData[{"Cameron",14},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",14},"RCN"]

GraphData[{"Cameron",14},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",14},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",14},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",14},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",14},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",14},"Circulant"]

GraphData[{"Cameron",14},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",14},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",14}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",14},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",14},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",14},"Line"]

LineGraphQ[GraphData[{"Cameron",14}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",14}&]

RootGraph[GraphData[{"Cameron",14}]]

Halin

GraphData[{"Cameron",14},"Halin"]

GraphData[{"Cameron",14},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",14},"Rigid"]

GraphData[{"Cameron",14},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",14},"Flexible"]

GraphData[{"Cameron",14},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",14},"LCF"]

GraphData[{"Cameron",14},"HamiltonianCycleCount"]

GraphData[{"Cameron",14},"LCFSignature"]

GraphData[{"Cameron",14},"LCFNotations"]

GraphData[{"Cameron",14},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",14},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",14}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",14}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",14},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",14}],Debug->True]//Timing

GraphData[{"Cameron",14},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",14},"VertexList"],GraphData[{"Cameron",14},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",14},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",14}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",14}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",14},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",14}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",14},"Matchstick"]

GraphData[{"Cameron",14},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",14},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",14},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",14},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",14},"Polyhedral"]

GraphData[{"Cameron",14},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",14},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",14},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",14},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",14}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",14},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 15}

Names

GraphData[{"Cameron",15},"StandardName"]

GraphData[{"Cameron",15},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[15,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",15}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",15},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",15},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",15}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",15},"VertexList"],GraphData[{"Cameron",15},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",15},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",15},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",15},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",15},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",15},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",15},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",15},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",15},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",15},"Hamiltonian"]

GraphData[{"Cameron",15},"LCF"]

GraphData[{"Cameron",15},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",15},"Planar"]

GraphData[{"Cameron",15},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",15}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",15}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",15},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",15}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",15}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",15}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",15},"CN"]

GraphData[{"Cameron",15},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",15},"RCN"]

GraphData[{"Cameron",15},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",15},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",15},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",15},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",15},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",15},"Circulant"]

GraphData[{"Cameron",15},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",15},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",15}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",15},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",15},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",15},"Line"]

LineGraphQ[GraphData[{"Cameron",15}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",15}&]

RootGraph[GraphData[{"Cameron",15}]]

Halin

GraphData[{"Cameron",15},"Halin"]

GraphData[{"Cameron",15},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",15},"Rigid"]

GraphData[{"Cameron",15},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",15},"Flexible"]

GraphData[{"Cameron",15},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",15},"LCF"]

GraphData[{"Cameron",15},"HamiltonianCycleCount"]

GraphData[{"Cameron",15},"LCFSignature"]

GraphData[{"Cameron",15},"LCFNotations"]

GraphData[{"Cameron",15},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",15},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",15}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",15}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",15},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",15}],Debug->True]//Timing

GraphData[{"Cameron",15},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",15},"VertexList"],GraphData[{"Cameron",15},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",15},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",15}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",15}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",15},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",15}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",15},"Matchstick"]

GraphData[{"Cameron",15},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",15},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",15},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",15},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",15},"Polyhedral"]

GraphData[{"Cameron",15},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",15},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",15},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",15},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",15}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",15},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 16}

Names

GraphData[{"Cameron",16},"StandardName"]

GraphData[{"Cameron",16},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[16,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",16}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",16},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",16},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",16}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",16},"VertexList"],GraphData[{"Cameron",16},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",16},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",16},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",16},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",16},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",16},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",16},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",16},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",16},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",16},"Hamiltonian"]

GraphData[{"Cameron",16},"LCF"]

GraphData[{"Cameron",16},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",16},"Planar"]

GraphData[{"Cameron",16},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",16}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",16}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",16},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",16}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",16}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",16}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",16},"CN"]

GraphData[{"Cameron",16},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",16},"RCN"]

GraphData[{"Cameron",16},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",16},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",16},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",16},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",16},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",16},"Circulant"]

GraphData[{"Cameron",16},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",16},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",16}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",16},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",16},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",16},"Line"]

LineGraphQ[GraphData[{"Cameron",16}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",16}&]

RootGraph[GraphData[{"Cameron",16}]]

Halin

GraphData[{"Cameron",16},"Halin"]

GraphData[{"Cameron",16},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",16},"Rigid"]

GraphData[{"Cameron",16},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",16},"Flexible"]

GraphData[{"Cameron",16},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",16},"LCF"]

GraphData[{"Cameron",16},"HamiltonianCycleCount"]

GraphData[{"Cameron",16},"LCFSignature"]

GraphData[{"Cameron",16},"LCFNotations"]

GraphData[{"Cameron",16},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",16},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",16}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",16}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",16},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",16}],Debug->True]//Timing

GraphData[{"Cameron",16},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",16},"VertexList"],GraphData[{"Cameron",16},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",16},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",16}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",16}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",16},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",16}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",16},"Matchstick"]

GraphData[{"Cameron",16},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",16},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",16},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",16},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",16},"Polyhedral"]

GraphData[{"Cameron",16},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",16},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",16},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",16},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",16}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",16},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 17}

Names

GraphData[{"Cameron",17},"StandardName"]

GraphData[{"Cameron",17},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[17,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",17}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",17},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",17},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",17}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",17},"VertexList"],GraphData[{"Cameron",17},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",17},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",17},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",17},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",17},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",17},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",17},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",17},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",17},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",17},"Hamiltonian"]

GraphData[{"Cameron",17},"LCF"]

GraphData[{"Cameron",17},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",17},"Planar"]

GraphData[{"Cameron",17},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",17}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",17}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",17},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",17}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",17}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",17}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",17},"CN"]

GraphData[{"Cameron",17},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",17},"RCN"]

GraphData[{"Cameron",17},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",17},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",17},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",17},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",17},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",17},"Circulant"]

GraphData[{"Cameron",17},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",17},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",17}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",17},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",17},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",17},"Line"]

LineGraphQ[GraphData[{"Cameron",17}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",17}&]

RootGraph[GraphData[{"Cameron",17}]]

Halin

GraphData[{"Cameron",17},"Halin"]

GraphData[{"Cameron",17},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",17},"Rigid"]

GraphData[{"Cameron",17},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",17},"Flexible"]

GraphData[{"Cameron",17},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",17},"LCF"]

GraphData[{"Cameron",17},"HamiltonianCycleCount"]

GraphData[{"Cameron",17},"LCFSignature"]

GraphData[{"Cameron",17},"LCFNotations"]

GraphData[{"Cameron",17},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",17},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",17}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",17}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",17},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",17}],Debug->True]//Timing

GraphData[{"Cameron",17},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",17},"VertexList"],GraphData[{"Cameron",17},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",17},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",17}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",17}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",17},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",17}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",17},"Matchstick"]

GraphData[{"Cameron",17},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",17},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",17},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",17},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",17},"Polyhedral"]

GraphData[{"Cameron",17},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",17},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",17},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",17},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",17}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",17},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 18}

Names

GraphData[{"Cameron",18},"StandardName"]

GraphData[{"Cameron",18},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[18,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",18}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",18},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",18},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",18}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",18},"VertexList"],GraphData[{"Cameron",18},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",18},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",18},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",18},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",18},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",18},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",18},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",18},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",18},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",18},"Hamiltonian"]

GraphData[{"Cameron",18},"LCF"]

GraphData[{"Cameron",18},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",18},"Planar"]

GraphData[{"Cameron",18},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",18}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",18}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",18},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",18}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",18}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",18}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",18},"CN"]

GraphData[{"Cameron",18},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"Cameron",18},"RCN"]

GraphData[{"Cameron",18},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Cameron",18},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",18},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",18},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",18},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",18},"Circulant"]

GraphData[{"Cameron",18},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",18},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",18}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",18},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",18},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",18},"Line"]

LineGraphQ[GraphData[{"Cameron",18}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",18}&]

RootGraph[GraphData[{"Cameron",18}]]

Halin

GraphData[{"Cameron",18},"Halin"]

GraphData[{"Cameron",18},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",18},"Rigid"]

GraphData[{"Cameron",18},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",18},"Flexible"]

GraphData[{"Cameron",18},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",18},"LCF"]

GraphData[{"Cameron",18},"HamiltonianCycleCount"]

GraphData[{"Cameron",18},"LCFSignature"]

GraphData[{"Cameron",18},"LCFNotations"]

GraphData[{"Cameron",18},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",18},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",18}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",18}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",18},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",18}],Debug->True]//Timing

GraphData[{"Cameron",18},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",18},"VertexList"],GraphData[{"Cameron",18},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",18},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",18}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",18}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",18},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",18}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",18},"Matchstick"]

GraphData[{"Cameron",18},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",18},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",18},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",18},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",18},"Polyhedral"]

GraphData[{"Cameron",18},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",18},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",18},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",18},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",18}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",18},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 19}

Names

GraphData[{"Cameron",19},"StandardName"]

GraphData[{"Cameron",19},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[19,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",19}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",19},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",19},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",19}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",19},"VertexList"],GraphData[{"Cameron",19},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",19},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",19},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",19},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",19},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",19},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",19},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",19},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",19},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",19},"Hamiltonian"]

GraphData[{"Cameron",19},"LCF"]

GraphData[{"Cameron",19},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",19},"Planar"]

GraphData[{"Cameron",19},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",19}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",19}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",19},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",19}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",19}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",19}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",19},"CN"]

GraphData[{"Cameron",19},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Cameron",19}],TimeConstraint->1])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Cameron",19}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

tuttegraphs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[tuttegraphs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Cameron",19},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[tuttegraphs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",19},"V"]])]==0&]

Select[tuttegraphs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",19},"V"]])]==1&]

(gs=Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Cameron",19}],"CrossingNumber"->cn,RandomSeed->n]],{n,1000}]//Union)//Timing

Select[gs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",19},"V"]])]==0&]

Select[gs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",19},"V"]])]==1&]

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Cameron",19},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Cameron",19},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",19},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",19},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",19},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",19},"Circulant"]

GraphData[{"Cameron",19},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",19},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",19}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",19},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",19},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",19},"Line"]

LineGraphQ[GraphData[{"Cameron",19}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",19}&]

RootGraph[GraphData[{"Cameron",19}]]

Halin

GraphData[{"Cameron",19},"Halin"]

GraphData[{"Cameron",19},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",19},"Rigid"]

GraphData[{"Cameron",19},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",19},"Flexible"]

GraphData[{"Cameron",19},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",19},"LCF"]

GraphData[{"Cameron",19},"HamiltonianCycleCount"]

GraphData[{"Cameron",19},"LCFSignature"]

GraphData[{"Cameron",19},"LCFNotations"]

GraphData[{"Cameron",19},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",19},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",19}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",19}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",19},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",19}],Debug->True]//Timing

GraphData[{"Cameron",19},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",19},"VertexList"],GraphData[{"Cameron",19},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",19},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",19}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",19}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",19},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",19}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",19},"Matchstick"]

GraphData[{"Cameron",19},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",19},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",19},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",19},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",19},"Polyhedral"]

GraphData[{"Cameron",19},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",19},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",19},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",19},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",19}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",19},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Cameron", 20}

Names

GraphData[{"Cameron",20},"StandardName"]

GraphData[{"Cameron",20},"StandardNames"]

Cameron construction

gs=Table[CameronGraph[20,GraphLayout->layout],{layout,{"KnuthConstruction","TwistedEmbedding"}}]

RecognizeGraph/@gs

VertexList[gs[[1]]]

Primary

GraphData[{"Cameron",20}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Cameron",20},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"Cameron",20},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"Cameron",20}]]

Default embedding

GraphPlot[Graph[GraphData[{"Cameron",20},"VertexList"],GraphData[{"Cameron",20},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"Cameron",20},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Cameron",20},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"Cameron",20},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"Cameron",20},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Cameron",20},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"Cameron",20},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Cameron",20},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"Cameron",20},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"Cameron",20},"Hamiltonian"]

GraphData[{"Cameron",20},"LCF"]

GraphData[{"Cameron",20},"HamiltonianCycleCount"]

Planar

GraphData[{"Cameron",20},"Planar"]

GraphData[{"Cameron",20},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"Cameron",20}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"Cameron",20}]],10]

PlanarGraphEmbeddings

GraphData[{"Cameron",20},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"Cameron",20}],Debug->True])//Timing

Length[plemb]

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Cameron",20}]]

Tally[ReverseSort[Length/@faces]]

gs=IGLayoutTutte[GraphData[{"Cameron",20}],"OuterFace"->#]&/@faces

TextGrid[DeleteCases[{#,GraphSymmetryGroup[#]}&/@gs,{_,TransformationGroup[{}]}],Dividers->All]

Grid[DeleteCases[{#,Cases[GraphSymmetryGroup[#],r_Rotation:>r,∞]}&/@gs,{_,{}}],Dividers->All]

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

TutteLayoutManipulate[g_Graph]:=Manipulate[
With[{face=OuterFace[g]},
IGLayoutTutte[IGEdgeMap[(EuclideanDistance@@#)^pow&,EdgeWeight->IGEdgeVertexProp[VertexCoordinates],IGLayoutTutte[g,"OuterFace"->face]],"OuterFace"->face,ImageSize->Automatic]],{{pow,1},.1,2}]

TutteLayoutManipulate[]

v=Join[];
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

MinimalCrossing

GraphData[{"Cameron",20},"CN"]

GraphData[{"Cameron",20},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Cameron",20}],TimeConstraint->1])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"Cameron",20}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

tuttegraphs=IGLayoutTutte[g,"OuterFace"->#]&/@faces

Select[tuttegraphs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Cameron",20},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[tuttegraphs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",20},"V"]])]==0&]

Select[tuttegraphs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",20},"V"]])]==1&]

(gs=Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Cameron",20}],"CrossingNumber"->cn,RandomSeed->n]],{n,1000}]//Union)//Timing

Select[gs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",20},"V"]])]==0&]

Select[gs,Count[OuterFace[#],_?(GreaterThan[GraphData[{"Cameron",20},"V"]])]==1&]

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Cameron",20},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Cameron",20},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",20},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Cameron",20},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Cameron",20},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"Cameron",20},"Circulant"]

GraphData[{"Cameron",20},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"Cameron",20},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Cameron",20}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Cameron",20},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Cameron",20},"ComplementGraph","Name"]

Line graph

GraphData[{"Cameron",20},"Line"]

LineGraphQ[GraphData[{"Cameron",20}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"Cameron",20}&]

RootGraph[GraphData[{"Cameron",20}]]

Halin

GraphData[{"Cameron",20},"Halin"]

GraphData[{"Cameron",20},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Cameron",20},"Rigid"]

GraphData[{"Cameron",20},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Cameron",20},"Flexible"]

GraphData[{"Cameron",20},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Cameron",20},"LCF"]

GraphData[{"Cameron",20},"HamiltonianCycleCount"]

GraphData[{"Cameron",20},"LCFSignature"]

GraphData[{"Cameron",20},"LCFNotations"]

GraphData[{"Cameron",20},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"Cameron",20},"V"]]

Length[FindHamiltonianCycle[GraphData[{"Cameron",20}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"Cameron",20}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

lcf

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"Cameron",20},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Cameron",20}],Debug->True]//Timing

GraphData[{"Cameron",20},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Cameron",20},"VertexList"],GraphData[{"Cameron",20},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"Cameron",20},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Cameron",20}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"Cameron",20}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"Cameron",20},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Cameron",20}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

g=;

Matchstick

GraphData[{"Cameron",20},"Matchstick"]

GraphData[{"Cameron",20},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Cameron",20},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"Cameron",20},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Cameron",20},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Cameron",20},"Polyhedral"]

GraphData[{"Cameron",20},"Graph",{"3D","Polyhedron"}]

Graphics3D[{FaceForm[Green,Red],GraphData[{"Cameron",20},"Polyhedron"]}]

3D Canonical

GraphData[{"Cameron",20},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Cameron",20},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Cameron",20}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

3D Canonical construction from PolyhedralEmbedding

g=GraphData[{"Cameron",20},"Graph","Planar"][[1]]

Show[g2=PolyhedralEmbedding[g,"Circular"->True,"Scale"->3],Boxed->True]//Quiet

With[
{faces=PlanarFaceList[Graph[EdgeList[g2]]],v=GraphEmbedding@g2},
Graphics3D[{Point[{0,0,0}],Opacity[.5],Sphere[],FaceForm[Green,Red],
poly=Polyhedron[1.2v,faces]}]]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->100,MaxIterations->20000,PrecisionGoal->20,"ProgressInterval"->100,"TangentFactor"->1/5,"PlanarFactor"->1/5,Debug->True])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

Properties

ABCEnergy

seq=Table[GraphData[{"Cameron",n},"ABCEnergy"],{n,20}]

ABCIndex

seq=Table[GraphData[{"Cameron",n},"ABCIndex"],{n,20}]

FindSequenceFunction[seq,n]

ABCSpectralRadius

seq=Table[GraphData[{"Cameron",n},"ABCSpectralRadius"],{n,20}]

Acyclic

Table[GraphData[{"Cameron",n},"Acyclic"],{n,20}]

Tally[%]

AdjacencyMatrixCount

seq=Table[GraphData[{"Cameron",n},"AdjacencyMatrixCount"],{n,20}]

AlgebraicConnectivity

seq=Table[GraphData[{"Cameron",n},"AlgebraicConnectivity"],{n,20}]

AlmostHamiltonian

Table[GraphData[{"Cameron",n},"AlmostHamiltonian"],{n,20}]

Anarboricity

seq=Table[GraphData[{"Cameron",n},"Anarboricity"],{n,20}]

Antipodal

Table[GraphData[{"Cameron",n},"Antipodal"],{n,20}]

Tally[%]

Apex

Table[GraphData[{"Cameron",n},"Apex"],{n,20}]

ApexCount

seq=Table[GraphData[{"Cameron",n},"ApexCount"],{n,20}]

FindSequenceFunction[seq,n]

Arboricity

Table[GraphData[{"Cameron",n},"Arboricity"],{n,20}]

ArcTransitive

Table[GraphData[{"Cameron",n},"ArcTransitive"],{n,20}]

ArcTransitivity

Table[GraphData[{"Cameron",n},"ArcTransitivity"],{n,20}]

ArithmeticGeometricEnergy

seq=Table[GraphData[{"Cameron",n},"ArithmeticGeometricEnergy"],{n,20}]

ArithmeticGeometricIndex

seq=Table[GraphData[{"Cameron",n},"ArithmeticGeometricIndex"],{n,20}]

FindSequenceFunction[seq,n]

ArithmeticGeometricSpectralRadius

seq=Table[GraphData[{"Cameron",n},"ArithmeticGeometricSpectralRadius"],{n,20}]

ArticulationVertexCount

seq=Table[GraphData[{"Cameron",n},"ArticulationVertexCount"],{n,20}]

AutomorphismCount

seq=Table[GraphData[{"Cameron",n},"AutomorphismCount"],{n,20}]

BalabanIndex

seq=Table[GraphData[{"Cameron",n},"BalabanIndex"],{n,20}]

Bandwidth

Inferred for n > 10:

Table[GraphData[{"Cameron",n},"Bandwidth"],{n,20}]

Bicolorable

Table[GraphData[{"Cameron",n},"Bicolorable"],{n,20}]

Biconnected

Table[GraphData[{"Cameron",n},"Biconnected"],{n,20}]

Bicubic

Table[GraphData[{"Cameron",n},"Bicubic"],{n,20}]

Bipartite

Table[GraphData[{"Cameron",n},"Bipartite"],{n,20}]

BipartiteDimension

seq=Table[GraphData[{"Cameron",n},"BipartiteDimension"],{n,20}]

Biplanar

Table[GraphData[{"Cameron",n},"Biplanar"],{n,20}]

Block

seq=Table[GraphData[{"Cameron",n},"Block"],{n,20}]

BlockCount

seq=Table[GraphData[{"Cameron",n},"BlockCount"],{n,20}]

BridgeCount

seq=Table[GraphData[{"Cameron",n},"BridgeCount"],{n,20}]

Bridged

Table[GraphData[{"Cameron",n},"Bridged"],{n,20}]

BroadcastTime

seq=Table[GraphData[{"Cameron",n},"BroadcastTime"],{n,20}]

BurningNumber

seq=Table[GraphData[{"Cameron",n},"BurningNumber"],{n,20}]

CharacteristicPolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"CharacteristicPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

CheegerConstant

seq=Table[GraphData[{"Cameron",n},"CheegerConstant"],{n,20}]

Chordal

Table[GraphData[{"Cameron",n},"Chordal"],{n,20}]

ChordCount

seq=Table[GraphData[{"Cameron",n},"ChordCount"],{n,20}]

FindSequenceFunction[seq,n]

ChordlessCycleCount

A387391

Inferred for n > 17:

seq=Table[GraphData[{"Cameron",n},"ChordlessCycleCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]//Factor

SeriesCoefficient[gf,{x,0,n}]

Table[-12+49 (2^(-2+n))-3 n,{n,20}]

-12+49 (2^(-2+n))-3n/.n->n+2//Simplify

seq=Table[49 (2^n)-3 n-18 ,{n,0,29}]

StringLength[ToString@seq]

coefs=FindLinearRecurrence[seq]

terms=Take[seq,Length@coefs]

LinearRecurrence[{4,-5,2},{31,77,172},20]

OEISRecurrenceString[coefs]

OEISRecurrenceIndexString[coefs]

gf=FindGeneratingFunction[seq,x]

OEISGeneratingFunctionString[gf,x]

CoefficientList[Series[((-31+47 x-19 (x^2))/((((-1+x))^2) (-1+2 x))),{x,0,20}],x]

ChordlessCyclePolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"ChordlessCyclePolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

ChromaticInvariant

Inferred for n > 6:

seq=Table[GraphData[{"Cameron",n},"ChromaticInvariant"],{n,20}]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

Simplify[SeriesCoefficient[gf,{x,0,n}],n>0]

ChromaticNumber

seq=Table[GraphData[{"Cameron",n},"ChromaticNumber"],{n,20}]

ChromaticPolynomial

(poly=Table[GraphData[{"Cameron",n},"ChromaticPolynomial"],{n,20}]/.f_Function:>f[x])//Column

ChromaticRoots

seq=Table[GraphData[{"Cameron",n},"ChromaticRoots"],{n,20}]

CircuitRank

seq=Table[GraphData[{"Cameron",n},"CircuitRank"],{n,20}]

FindSequenceFunction[seq,n]

Circumference

seq=Table[GraphData[{"Cameron",n},"Circumference"],{n,20}]

FindSequenceFunction[seq,n]

Classes

Intersection@@(GraphData[#,"Classes"]&/@GraphData["Cameron"])

GraphClassesThatAre["Cameron"]

ClawFree

Table[GraphData[{"Cameron",n},"ClawFree"],{n,20}]

CliqueCount

seq=Table[GraphData[{"Cameron",n},"CliqueCount"],{n,20}]

FindSequenceFunction[seq,n]

CliqueCoveringNumber

seq=Table[GraphData[{"Cameron",n},"CliqueCoveringNumber"],{n,20}]

FindSequenceFunction[seq,n]

CliqueNumber

seq=Table[GraphData[{"Cameron",n},"CliqueNumber"],{n,20}]

FindSequenceFunction[seq,n]

CliquePolynomial

(poly=Table[GraphData[{"Cameron",n},"CliquePolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]//Factor

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

Coarseness

seq=Table[GraphData[{"Cameron",n},"Coarseness"],{n,20}]

CoboundaryPolynomial

(poly=Table[GraphData[{"Cameron",n},"CoboundaryPolynomial"],{n,20}]/.f_Function:>f[x,y])//Column

ComplementChordlessCycleCount

seq=Table[GraphData[{"Cameron",n},"ComplementChordlessCycleCount"],{n,20}]

FindSequenceFunction[seq,n]//Factor

ComplementChordlessCyclePolynomial

(poly=Table[GraphData[{"Cameron",n},"ComplementChordlessCyclePolynomial"],{n,20}]/.f_Function:>f[x])

FindSequenceFunction[Coefficient[poly,x,4],n]

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"Cameron",n},"ComplementOddChordlessCycleCount"],{n,20}]

ComplementOddChordlessCyclePolynomial

poly=Table[GraphData[{"Cameron",n},"ComplementOddChordlessCyclePolynomial"],{n,20}]/.f_Function:>f[x]

Conductance

seq=Table[GraphData[{"Cameron",n},"Conductance"],{n,20}]

Connected

seq=Table[GraphData[{"Cameron",n},"Connected"],{n,20}]

ConnectedComponentCount

seq=Table[GraphData[{"Cameron",n},"ConnectedComponentCount"],{n,20}]

ConnectedDominatingSetCount

A387373

seq=Table[GraphData[{"Cameron",n},"ConnectedDominatingSetCount"],{n,20}]

seq=BFileSequence[387373]//Take[#,40]&

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

coefs=FindLinearRecurrence[DeleteMissing@seq]

OEISRecurrenceString[coefs]

terms=Take[seq,{1,Length@coefs}+1]

LinearRecurrence[{53,209,376,-673,71,-4479,2120,-428,320,16},{281,15949,905469,51427345,2920698969,165875085993,9420532825569,535019698383817,30385338406252141,1725672517842528533},{0,20}]

gf=FindGeneratingFunction[seq,x,ValidationLength->15]//Factor

CoefficientList[Series[((-5-16 x-11 (x^2)+437 (x^3)-1856 (x^4)+1403 (x^5)-5308 (x^6)+2044 (x^7)-656 (x^8)+368 (x^9))/(-1+53 x+209 (x^2)+376 (x^3)-673 (x^4)+71 (x^5)-4479 (x^6)+2120 (x^7)-428 (x^8)+320 (x^9)+16 (x^10))),{x,0,20}],x]

Refine[SeriesCoefficient[gf,{x,0,n}],n>0]

rootpowers=Cases[%153,r_Root^n f_:>f,∞]

rootpowers[[1]]//RootReduce//Timing

rootpowers=Cases[%153,r_Root^n f_:>r^n ToAlgebraicRoot[f,"MaxDegree"->10],∞]

rootpowers=Cases[%153,r_Root^n f_:>r^n RootReduce[f],∞]

InputForm[%]

Length[%]

N[%%]

ConnectedDominationNumber

Inferred for n > 8:

seq=Table[GraphData[{"Cameron",n},"ConnectedDominationNumber"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

ConnectedDominationPolynomial

(poly=Table[GraphData[{"Cameron",n},"ConnectedDominationPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

ConnectedInducedSubgraphCount

A387374

seq=Table[GraphData[{"Cameron",n},"ConnectedInducedSubgraphCount"],{n,20}]

seq=BFileSequence[A387374]//Take[#,30]&

coefs=FindLinearRecurrence[seq]

OEISRecurrenceString[coefs]

terms=Take[seq,Length@coefs]

LinearRecurrence[{68,-241,-666,651,-672,1775,4412,-10032,5170,-464},{421,26564,1702720,109099373,6990954434,447974968976,28705909073977,1839453802307198,117870864072599395,7553079389820352025},20]

gf=x FindGeneratingFunction[seq,x,ValidationLength->20]

gf=((x (421-2064 x-2171 (x^2)-3277 (x^3)-29857 (x^4)+17625 (x^5)+17634 (x^6)-19513 (x^7)+13630 (x^8)-1400 (x^9)))/((((1-x))^2) (1-66 x+108 (x^2)+948 (x^3)+1137 (x^4)+1998 (x^5)+1084 (x^6)-4242 (x^7)+464 (x^8))))//Factor

CoefficientList[Series[((421-2064 x-2171 (x^2)-3277 (x^3)-29857 (x^4)+17625 (x^5)+17634 (x^6)-19513 (x^7)+13630 (x^8)-1400 (x^9))/((((1-x))^2) (1-66 x+108 (x^2)+948 (x^3)+1137 (x^4)+1998 (x^5)+1084 (x^6)-4242 (x^7)+464 (x^8)))),{x,0,20}],x]

seriescoef=Refine[SeriesCoefficient[gf,{x,0,n}],n>0]

RootReduce[seriescoef]

ConnectedInducedSubgraphPolynomial

(poly=Table[GraphData[{"Cameron",n},"ConnectedInducedSubgraphPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

Corank

seq=Table[GraphData[{"Cameron",n},"Corank"],{n,20}]

FindSequenceFunction[seq,n]

CriticalNonplanar

Table[GraphData[{"Cameron",n},"CriticalNonplanar"],{n,20}]

CrossingNumber

seq=Table[GraphData[{"Cameron",n},"CrossingNumber"],{n,20}]

CubeGraphName

Table[GraphData[{"Cameron",n},"CubeGraphName"],{n,20}]

Cubic

Table[GraphData[{"Cameron",n},"Cubic"],{n,20}]

CycleCount

A387375

seq=Table[GraphData[{"Cameron",n},"CycleCount"],{n,20}]

coefs=FindLinearRecurrence[DeleteMissing@seq]

terms=Take[seq,Length@coefs]

LinearRecurrence[{10,-21,16,-4},{47,397,3031,22713},20]

OEISRecurrenceIndexString[coefs]

OEISRecurrenceString[coefs]

FullSimplify[FindSequenceFunction[DeleteMissing@seq,n]]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

CoefficientList[Series[((47-73 x+48 (x^2)-12 (x^3))/((((-1+x))^2) (1-8 x+4 (x^2)))),{x,0,20}],x]

OEISGeneratingFunctionString[gf,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

Table[(33-19 (Sqrt[3])) (((4-2 (Sqrt[3])))^n)+(((2 (2+(Sqrt[3]))))^n) (33+19 (Sqrt[3])),{n,10}]//Expand

Table[Sqrt[3]/4((Sqrt[3]-1)^(2n+5)+(Sqrt[3]+1)^(2n+5)),{n,10}]//Expand

seq=Table[((Sqrt[3]) (((((Sqrt[3])-1))^(2 n+5))+((((Sqrt[3])+1))^(2 n+5)))/4-30 n-39)/9,{n,20}]//Expand

StringLength[ToString[seq]]

Do[Print[{gn={"Cameron",n},FindCycle[GraphData[gn],Infinity,All]//Length//Timing,MaxMemoryUsed[]/10^9.}],{n,7}]

CyclePolynomial

(poly=Table[GraphData[{"Cameron",n},"CyclePolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

FindGeneratingFunction[DeleteMissing@poly,z]//Head//Timing

Cyclic

Table[GraphData[{"Cameron",n},"Cyclic"],{n,20}]

CyclicChromaticNumber

seq=Table[GraphData[{"Cameron",n},"CyclicChromaticNumber"],{n,20}]

CyclicEdgeConnectivity

seq=Table[GraphData[{"Cameron",n},"CyclicEdgeConnectivity"],{n,20}]

CyclicEdgeCutCount

seq=Table[GraphData[{"Cameron",n},"CyclicEdgeCutCount"],{n,20}]

CyclicEdgeCutPolynomial

(poly=Table[GraphData[{"Cameron",n},"CyclicEdgeCutPolynomial"],{n,20}]/.f_Function:>f[x])//Column

Degeneracy

seq=Table[GraphData[{"Cameron",n},"Degeneracy"],{n,20}]

DegreeCentralities

Tally/@Table[GraphData[{"Cameron",n},"DegreeCentralities"],{n,20}]//Column

Density

seq=Table[GraphData[{"Cameron",n},"Density"],{n,20}]

FindSequenceFunction[seq,n]

DetourIndex

A387684

Inferred for n > 5:

seq=Table[GraphData[{"Cameron",n},"DetourIndex"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//Factor

seq=Table[(8n+1)^2(4n+1),{n,0,31}]

StringLength@ToString@seq

coefs=FindLinearRecurrence[seq]

OEISRecurrenceString[coefs]

OEISRecurrenceIndexString[coefs]

terms=Take[seq,{1,Length@coefs}+1]

LinearRecurrence[{4,-6,4,-1},{405,2601,8125,18513},{0,20}]

gf=FindGeneratingFunction[seq,x]

OEISGeneratingFunctionString[gf,x]

CoefficientList[Series[((1+401 x+987 (x^2)+147 (x^3))/(((-1+x))^4)),{x,0,20}],x]

DetourPolynomial

Inferred for n > 5:

(poly=Table[GraphData[{"Cameron",n},"DetourPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

FindSequenceFunction[{81,289,625,1089,1681},n]//Factor

FindSequenceFunction[{9,17,25,33,41},n]//Factor

Table[(x-(((1+8 n))^2))(((1+8 n+x))^(1+8 n)),{n,20}]==poly

Diameter

seq=Table[GraphData[{"Cameron",n},"Diameter"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

Simplify[SeriesCoefficient[gf,{x,0,n}],n>0]

Dimension

seq=Table[GraphData[{"Cameron",n},"Dimension"],{n,20}]

DisorderNumber

seq=Table[GraphData[{"Cameron",n},"DisorderNumber"],{n,20}]

DistanceHereditary

seq=Table[GraphData[{"Cameron",n},"DistanceHereditary"],{n,20}]

DistancePolynomial

(poly=Table[GraphData[{"Cameron",n},"DistancePolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

DistanceRegular

Table[GraphData[{"Cameron",n},"DistanceRegular"],{n,20}]

DistanceTransitive

Table[GraphData[{"Cameron",n},"DistanceTransitive"],{n,20}]

DistinguishingNumber

seq=Table[GraphData[{"Cameron",n},"DistinguishingNumber"],{n,20}]

DomaticNumber

seq=Table[GraphData[{"Cameron",n},"DomaticNumber"],{n,20}]

DominatingSetCount

A387433

seq=Table[GraphData[{"Cameron",n},"DominatingSetCount"],{n,20}]

seq=BFileSequence[387433]//Take[#,50]&

coefs=FindLinearRecurrence[seq]

OEISRecurrenceString[coefs]

terms=Take[seq,1+Length@coefs]

LinearRecurrence[{171,1630,-3128,-60684,408220,1031036,1422260,896221,359221,94394,11884,948,452,100,4},{687,123445,22217385,3998015863,719448790681,129465806292261,23297551477617903,4192426713354818233,754433003972842510279,135761265825306788853311,24430428151245174661992773,4396289442536280242818423199,791118384946146380633498854261,142362851031647945042577554446105,25618392568691002593830067445166555},{0,20}]

(gf=FindGeneratingFunction[seq,x,ValidationLength->15])//Timing

FindGeneratingFunction[seq,x,ValidationLength->20]//Head//Timing

(cn=SeriesCoefficient[gf,{x,0,n}])//Timing

RootReduce[FullSimplify[cn,n>0]]

CoefficientList[Series[((-15+1878 x+18482 (x^2)-35400 (x^3)-686874 (x^4)+4556874 (x^5)+11566900 (x^6)+16131486 (x^7)+10027805 (x^8)+4043804 (x^9)+1071150 (x^10)+156386 (x^11)+24612 (x^12)+5092 (x^13)+204 (x^14))/(-1+171 x+1630 (x^2)-3128 (x^3)-60684 (x^4)+408220 (x^5)+1031036 (x^6)+1422260 (x^7)+896221 (x^8)+359221 (x^9)+94394 (x^10)+11884 (x^11)+948 (x^12)+452 (x^13)+100 (x^14)+4 (x^15))),{x,0,20}],x]

DominationNumber

seq=Table[GraphData[{"Cameron",n},"DominationNumber"],{n,20}]

FindSequenceFunction[seq,n]

FindLinearRecurrence[seq]

gf=x FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0&&n∈Integers]

DominationPolynomial

(poly=Table[GraphData[{"Cameron",n},"DominationPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

Doublecross

Table[GraphData[{"Cameron",n},"Doublecross"],{n,20}]

Eccentricities

(Table[GraphData[{"Cameron",n},"Eccentricities"],{n,20}])//Column

EccentricityCentralities

(Tally/@Table[GraphData[{"Cameron",n},"EccentricityCentralities"],{n,20}])//Column

EdgeBetweennessCentralities

(Tally/@Table[GraphData[{"Cameron",n},"EdgeBetweennessCentralities"],{n,20}])//Column

EdgeChromaticNumber

seq=Table[GraphData[{"Cameron",n},"EdgeChromaticNumber"],{n,20}]

EdgeConnectivity

Table[GraphData[{"Cameron",n},"EdgeConnectivity"],{n,20}]

EdgeCount

seq=Table[GraphData[{"Cameron",n},"EdgeCount"],{n,20}]

FindSequenceFunction[seq,n]

EdgeCoverCount

seq=Table[GraphData[{"Cameron",n},"EdgeCoverCount"],{n,20}]

EdgeCoverNumber

seq=Table[GraphData[{"Cameron",n},"EdgeCoverNumber"],{n,20}]

FindSequenceFunction[seq,n]

EdgeCoverPolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"EdgeCoverPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

EdgeCutCount

seq=Table[GraphData[{"Cameron",n},"EdgeCutCount"],{n,20}]

EdgeTransitive

Table[GraphData[{"Cameron",n},"EdgeTransitive"],{n,20}]

EigenvectorCentralities

Tally/@Table[GraphData[{"Cameron",n},"EigenvectorCentralities"],{n,20}]//Column

EulerianCycleCount

seq=Table[GraphData[{"Cameron",n},"EulerianCycleCount"],{n,20}]

FaceCount

seq=Table[GraphData[{"Cameron",n},"FaceCount"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

Simplify[SeriesCoefficient[gf,{x,0,n}],n>5]

FixingNumber

seq=Table[GraphData[{"Cameron",n},"FixingNumber"],{n,20}]

FlowPolynomial

Inferred for n > 6:

(poly=Table[GraphData[{"Cameron",n},"FlowPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

Table[(((-3+x))^(4n))(-2+x)(-1+x),{n,20}]==poly

FractionalArboricity

seq=Table[GraphData[{"Cameron",n},"FractionalArboricity"],{n,20}]

FractionalChromaticNumber

seq=Table[GraphData[{"Cameron",n},"FractionalChromaticNumber"],{n,20}]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"Cameron",n},"FractionalEdgeChromaticNumber"],{n,20}]

FractionalIndependenceNumber

seq=Table[GraphData[{"Cameron",n},"FractionalIndependenceNumber"],{n,20}]

FindSequenceFunction[seq,n]

Genus

seq=Table[GraphData[{"Cameron",n},"Genus"],{n,20}]

Geodetic

Table[GraphData[{"Cameron",n},"Geodetic"],{n,20}]

Girth

seq=Table[GraphData[{"Cameron",n},"Girth"],{n,20}]

GlobalClusteringCoefficient

seq=Table[GraphData[{"Cameron",n},"GlobalClusteringCoefficient"],{n,20}]

FindSequenceFunction[seq,n]

Gonality

seq=Table[GraphData[{"Cameron",n},"Gonality"],{n,20}]

Graceful

Table[GraphData[{"Cameron",n},"Graceful"],{n,20}]

GracefulLabelingCount

seq=Table[GraphData[{"Cameron",n},"GracefulLabelingCount"],{n,20}]

HadwigerNumber

Table[GraphData[{"Cameron",n},"HadwigerNumber"],{n,20}]

HaemersNumber

Table[GraphData[{"Cameron",n},"HaemersNumber"],{n,20}]

HamiltonConnected

Inferred for n > 7:

Table[GraphData[{"Cameron",n},"HamiltonConnected"],{n,20}]

HamiltonDecomposable

Table[GraphData[{"Cameron",n},"HamiltonDecomposable"],{n,20}]

HamiltonDecompositionCount

seq=Table[GraphData[{"Cameron",n},"HamiltonDecompositionCount"],{n,20}]

Hamiltonian

Table[GraphData[{"Cameron",n},"Hamiltonian"],{n,20}]

HamiltonianCycleCount

A010701

seq=Table[GraphData[{"Cameron",n},"HamiltonianCycleCount"],{n,20}]

HamiltonianNumber

seq=Table[GraphData[{"Cameron",n},"HamiltonianNumber"],{n,20}]

FindSequenceFunction[seq,n]

HamiltonianPathCount

A387438

seq=Table[GraphData[{"Cameron",n},"HamiltonianPathCount"],{n,20}]

seq=BFileSequence[387438]//Take[#,50]&

coefs=FindLinearRecurrence[seq]

OEISRecurrenceString[coefs]

terms=Take[seq,1+{1,Length@coefs}]

LinearRecurrence[{5,-5,1,-1,1,-1,1},{106,614,2658,10406,39298,146618,544858},{0,20}]

gf=FindGeneratingFunction[seq,x]

CoefficientList[Series[-((2 (1+48 x+47 (x^2)+58 (x^3)+41 (x^4)+24 (x^5)+5 (x^6)))/((((-1+x))^2) (-1+3 x+2 (x^2)+2 (x^3)+(x^4)+(x^5)))),{x,0,20}],x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

InputForm[%]

f1=-1-#1-2*#1^2-2*#1^3-3*#1^4+#1^5&; (* root^n *)
f2=-2972176-5578208*#1-2766784*#1^2-179404*#1^3-51121*#1^4+469*#1^5&; (* ... * root^n *)
pos={1,3,2,5,4};

an=ToNumberField[Root[f2,#],Root[f1,pos[[#]]]]&/@Range[3]

coeffs=an[[All,-1]]

SameQ@@coeffs

RootSum[f1,Evaluate[((#)^(n+Range[Length[pos]]-1)).an[[1,2]]]&]

FullSimplify@(1/2) (7-112 (1+n)+(1/938) RootSum[-1-#1-2 ((#1)^2)-2 ((#1)^3)-3 ((#1)^4)+((#1)^5)&,-3391 ((#1)^n)-6806 ((#1)^(1+n))-7388 ((#1)^(2+n))-1846 ((#1)^(3+n))+1745 ((#1)^(4+n))&])

Table[(7-112 (n+1)+(1/938) RootSum[-1-#-2 ((#)^2)-2 ((#)^3)-3 ((#)^4)+((#)^5)&,-3391 ((#)^n)-6806 ((#)^(n+1))-7388 ((#)^(n+2))-1846 ((#)^(n+3))+1745 ((#)^(n+4))&])/2,{n,0,20}]

HamiltonianWalkCount

seq=Table[GraphData[{"Cameron",n},"HamiltonianWalkCount"],{n,20}]

HamiltonLaceable

Table[GraphData[{"Cameron",n},"HamiltonLaceable"],{n,20}]

HararyIndex

seq=Table[GraphData[{"Cameron",n},"HararyIndex"],{n,20}]

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

HexagonCount

seq=Table[GraphData[{"Cameron",n},"HexagonCount"],{n,20}]

FindSequenceFunction[seq,n]

HosoyaIndex

=== IndependentEdgeSetCount

seq=Table[GraphData[{"Cameron",n},"HosoyaIndex"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

HStarConnected

Inferred for n > 7:

Table[GraphData[{"Cameron",n},"HStarConnected"],{n,20}]

Hypohamiltonian

Table[GraphData[{"Cameron",n},"Hypohamiltonian"],{n,20}]

Hypotraceable

Table[GraphData[{"Cameron",n},"Hypotraceable"],{n,20}]

Identity

Table[GraphData[{"Cameron",n},"Identity"],{n,20}]

IdiosyncraticPolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"IdiosyncraticPolynomial"],{n,k0=1,20}]/.f_Function:>f[x,y])//Column

Iconize[Join[,l]]

Length[idio=]

idio[[All,1]]

poly=idio[[All,2,2]]

Length@DeleteMissing@poly

FindLinearRecurrence[DeleteMissing@poly]//Head//Timing

IndependenceNumber

seq=Table[GraphData[{"Cameron",n},"IndependenceNumber"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

Simplify[SeriesCoefficient[gf,{x,0,n}],n>1]

IndependencePolynomial

(poly=Table[GraphData[{"Cameron",n},"IndependencePolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

FindLinearRecurrence[DeleteMissing@seq]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,z]//Head//Timing

IndependenceRatio

seq=Table[GraphData[{"Cameron",n},"IndependenceRatio"],{n,20}]

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]//FullSimplify

Table[(((((-1))^n) (-1+(((-1))^n) (5+14 n)))/(8+32 n)),{n,20}]

gf=x FindGeneratingFunction[seq,x]

IndependentEdgeSetCount

A387559

seq=Table[GraphData[{"Cameron",n},"IndependentEdgeSetCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

FindLinearRecurrence[DeleteMissing@seq]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

IndependentVertexSetCount

A387561

seq=Table[GraphData[{"Cameron",n},"IndependentVertexSetCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

IntersectionNumber

seq=Table[GraphData[{"Cameron",n},"IntersectionNumber"],{n,20}]

IrredundanceNumber

seq=Table[GraphData[{"Cameron",n},"IrredundanceNumber"],{n,20}]

IrredundancePolynomial

(poly=Table[GraphData[{"Cameron",n},"IrredundancePolynomial"],{n,20}]/.f_Function:>f[x])//Column

IrredundantSetCount

seq=Table[GraphData[{"Cameron",n},"IrredundantSetCount"],{n,20}]

IrregularityStrength

A047539

seq=Table[GraphData[{"Cameron",n},"IrregularityStrength"],{n,20}]

FullSimplify[FindSequenceFunction[seq,n]]

Table[Floor[2(4 n+3)/3],{n,20}]

IsolatedPointCount

seq=Table[GraphData[{"Cameron",n},"IsolatedPointCount"],{n,20}]

KatzCentralities

Tally/@(poly=Table[GraphData[{"Cameron",n},"KatzCentralities"],{n,20}]/.f_Function:>f[x,y])//Column

KirchhoffIndex

seq=Table[GraphData[{"Cameron",n},"KirchhoffIndex"],{n,20}]

KirchhoffSumIndex

seq=Table[GraphData[{"Cameron",n},"KirchhoffSumIndex"],{n,20}]

LaplacianPolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"LaplacianPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

LaplacianSpectralRadius

seq=Table[GraphData[{"Cameron",n},"LaplacianSpectralRadius"],{n,20}]

LaplacianSpectralRatio

seq=Table[GraphData[{"Cameron",n},"LaplacianSpectralRadius"],{n,20}]

LeafCount

seq=Table[GraphData[{"Cameron",n},"LeafCount"],{n,20}]

Likelihood

seq=Table[GraphData[{"Cameron",n},"Likelihood"],{n,20}]

LinearArboricity

seq=Table[GraphData[{"Cameron",n},"LinearArboricity"],{n,20}]

LocalClusteringCoefficients

Tally/@Sort/@Table[GraphData[{"Cameron",n},"LocalClusteringCoefficients"],{n,20}]//Column

LocalCrossingNumber

seq=Table[GraphData[{"Cameron",n},"LocalCrossingNumber"],{n,20}]

LongestCycleCount

seq=Table[GraphData[{"Cameron",n},"LongestCycleCount"],{n,20}]

LongestPathCount

== HamiltonianPathCount

A387438

seq=Table[GraphData[{"Cameron",n},"LongestPathCount"],{n,20}]

LongestPathLength

A017077

seq=Table[GraphData[{"Cameron",n},"LongestPathLength"],{n,20}]

FindSequenceFunction[seq,n]

LovaszNumber

seq=Table[GraphData[{"Cameron",n},"LovaszNumber"],{n,20}]

LowerCliqueNumber

seq=Table[GraphData[{"Cameron",n},"LowerCliqueNumber"],{n,20}]

LowerIndependenceNumber

A047215

Inferred for n == 20:

seq=Table[GraphData[{"Cameron",n},"LowerIndependenceNumber"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

SeriesCoefficient[gf,{x,0,n}]

LowerMatchingNumber

seq=Table[GraphData[{"Cameron",n},"LowerMatchingNumber"],{n,20}]

FindSequenceFunction[seq,n]

gf=FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]//FullSimplify

MapNumber

seq=Table[GraphData[{"Cameron",n},"MapNumber"],{n,20}]

MatchingGeneratingPolynomial

(poly=Table[GraphData[{"Cameron",n},"MatchingGeneratingPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

MatchingNumber

A016813

seq=Table[GraphData[{"Cameron",n},"MatchingNumber"],{n,20}]

FindSequenceFunction[seq,n]

MatchingPolynomial

(poly=Table[GraphData[{"Cameron",n},"MatchingPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

MaximalCliqueCount

A017653

seq=Table[GraphData[{"Cameron",n},"MaximalCliqueCount"],{n,20}]

FindSequenceFunction[seq,n]

MaximalCliquePolynomial

(poly=Table[GraphData[{"Cameron",n},"MaximalCliquePolynomial"],{n,20}]/.f_Function:>f[x])//Column

MaximalIndependencePolynomial

(poly=Table[GraphData[{"Cameron",n},"MaximalIndependencePolynomial"],{n,20}]/.f_Function:>f[x])//Column

MaximalIndependentEdgeSetCount

A387588

seq=Table[GraphData[{"Cameron",n},"MaximalIndependentEdgeSetCount"],{n,20}]

seq=BFileSequence[387588]

gf=(2+9 x-32 (x^2)+274 (x^3)-1133 (x^4)+290 (x^5)-3417 (x^6)-12087 (x^7)-5747 (x^8)+10436 (x^9)+4441 (x^10)-7402 (x^11)-4676 (x^12)+1509 (x^13)+2127 (x^14)+523 (x^15)-408 (x^16)-201 (x^17)-33 (x^18)+13 (x^19)+11 (x^20))/(1-25 x+54 (x^2)-611 (x^3)-69 (x^4)-2754 (x^5)-4677 (x^6)-1125 (x^7)+6183 (x^8)+8571 (x^9)+5215 (x^10)-1854 (x^11)-5319 (x^12)-3171 (x^13)-279 (x^14)+712 (x^15)+420 (x^16)+42 (x^17)-70 (x^18)-44 (x^19)-11 (x^20)-(x^21));

SeriesCoefficient[gf,{x,0,n}]

sercoef=Refine[%154,n>0]

rootterms=Cases[sercoef,r_Root^n f_:>r^n f]

Length[rootterms]

rootterms[[1]]/.r_Root^n f_:>r^n RootReduce[f]

CoefficientList[Series[(2+9x-32x^2+274x^3-1133x^4+290x^5-3417x^6-12087x^7-5747x^8+10436x^9+4441x^10-7402x^11-4676x^12+1509x^13+2127x^14+523x^15-408x^16-201x^17-33x^18+13x^19+11x^20)/(1-25x+54x^2-611x^3-69x^4-2754x^5-4677x^6-1125x^7+6183x^8+8571x^9+5215x^10-1854x^11-5319x^12-3171x^13-279x^14+712x^15+420x^16+42x^17-70x^18-44x^19-11x^20-x^21),{x,0,25}],x]

seq=CoefficientList[Series[(2+9*x-32*x^2+274*x^3-1133*x^4+290*x^5-3417*x^6-12087*x^7-5747*x^8+10436*x^9+4441*x^10-7402*x^11-4676*x^12+1509*x^13+2127*x^14+523*x^15-408*x^16-201*x^17-33*x^18+13*x^19+11*x^20)/(1-25*x+54*x^2-611*x^3-69*x^4-2754*x^5-4677*x^6-1125*x^7+6183*x^8+8571*x^9+5215*x^10-1854*x^11-5319*x^12-3171*x^13-279*x^14+712*x^15+420*x^16+42*x^17-70*x^18-44*x^19-11*x^20-x^21),{x,0,50}],x]

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

coef=FindLinearRecurrence[seq]

OEISRecurrenceString[coef]

Length@coef

terms=Take[seq,Length@coef]

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

LinearRecurrence[{25,-54,611,69,2754,4677,1125,-6183,-8571,-5215,1854,5319,3171,279,-712,-420,-42,70,44,11,1},{2,59,1335,31685,755089,17991789,428639992,10211931534,243290365549,5796184140665,138089097921502,3289853805016152,78377933085127634,1867286744406019994,44486498286400651396,1059852502913712744001,25250072970400608015188,601561239189816500643502,14331678364647007901043854,341439892344651885580076566,8134511333432232355757666364},25]

MaximalIndependentVertexSetCount

A387589

seq=Table[GraphData[{"Cameron",n},"MaximalIndependentVertexSetCount"],{n,20}]

l=BFileList[387589,"Cameron"]

gf=((x (14-21 x+60 (x^2)-36 (x^3)+30 (x^4)+20 (x^5)-38 (x^6)-4 (x^7)+6 (x^8)+(x^9)))/(1-8 x+10 (x^2)-22 (x^3)+4 (x^4)-7 (x^5)-7 (x^6)+8 (x^7)-(x^9)));

seq=CoefficientList[Series[((14-21 x+60 (x^2)-36 (x^3)+30 (x^4)+20 (x^5)-38 (x^6)-4 (x^7)+6 (x^8)+(x^9))/(1-8 x+10 (x^2)-22 (x^3)+4 (x^4)-7 (x^5)-7 (x^6)+8 (x^7)-(x^9))),{x,0,60}],x]

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

FindLinearRecurrence[DeleteMissing@seq]//Head//Timing

Options[FindLinearRecurrence]

coef={8,-10,22,-4,7,7,-8,0,1};

OEISRecurrenceString[coef]

terms=Take[seq,Length@coef]

LinearRecurrence[{8,-10,22,-4,7,7,-8,0,1},{14,91,648,4546,31864,223462,1567173,10990645,77077774},20]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

gfcoef=Refine[SeriesCoefficient[gf,{x,0,n}],n>0]

MaximalIrredundancePolynomial

(poly=Table[GraphData[{"Cameron",n},"MaximalIrredundancePolynomial"],{n,20}]/.f_Function:>f[x])//Column

MaximalIrredundantSetCount

seq=Table[GraphData[{"Cameron",n},"MaximalIrredundantSetCount"],{n,20}]

MaximalMatchingGeneratingPolynomial

(poly=Table[GraphData[{"Cameron",n},"MaximalMatchingGeneratingPolynomial"],{n,20}]/.f_Function:>f[x])//Column

MaximumCliqueCount

seq=Table[GraphData[{"Cameron",n},"MaximumCliqueCount"],{n,20}]

MaximumIndependentEdgeSetCount

A387596

Inferred for n > 16:

seq=Table[GraphData[{"Cameron",n},"MaximumIndependentEdgeSetCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//FullSimplify

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

OEISGeneratingFunctionString[gf,x]

CoefficientList[Series[((-7+x+14 (x^2)-3 (x^3))/(-1+3 x+(x^2)-5 (x^3)+(x^4))),{x,0,20}],x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0&&n∈Integers]

InputForm[n +n +n +n ]

f1=-1+5*#1-#1^2-3*#1^3+#1^4&; (* root^n *)
f2=3-189*#1+1609*#1^2-3981*#1^3+1327*#1^4&; (* ... * root^n *)
pos={2,3,1,4};

an=ToNumberField[Root[f2,#],Root[f1,pos[[#]]]]&/@Range[3]

coeffs=an[[All,-1]]

SameQ@@coeffs

RootSum[f1,Evaluate[((#)^(n+Range[Length[pos]]-1)).an[[1,2]]]&]

seq=Table[((RootSum[-1+5 #-((#)^2)-3 ((#)^3)+((#)^4)&,74 ((#)^n)-262 ((#)^(n+1))+122 ((#)^(n+2))+149 ((#)^(n+3))&])/1327),{n,28}]

StringLength@ToString@seq

coefs=FindLinearRecurrence[seq]

OEISRecurrenceString[coefs]

OEISRecurrenceIndexString[coefs]

terms=Take[seq,Length@coefs]

LinearRecurrence[{3,1,-5,1},{7,20,53,147},20]

MaximumIndependentVertexSetCount

Inferred for n == 20:

seq=Table[GraphData[{"Cameron",n},"MaximumIndependentVertexSetCount"],{n,20}]

coefs=FindLinearRecurrence[Rest@seq]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

seriescoef=FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>1]

FullSimplify[seriescoef,Mod[n,2]==0]

FullSimplify[seriescoef,Mod[n,2]==1]

MaximumIrredundantSetCount

seq=Table[GraphData[{"Cameron",n},"MaximumIrredundantSetCount"],{n,20}]

MaximumLeafNumber

seq=Table[GraphData[{"Cameron",n},"MaximumLeafNumber"],{n,20}]

FindSequenceFunction[seq,n]

MaximumVertexDegree

seq=Table[GraphData[{"Cameron",n},"MaximumVertexDegree"],{n,20}]

MeanClusteringCoefficient

seq=Table[GraphData[{"Cameron",n},"MeanClusteringCoefficient"],{n,20}]

FindSequenceFunction[seq,n]

MeanDistance

seq=Table[GraphData[{"Cameron",n},"MeanDistance"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>1]

Median

seq=Table[GraphData[{"Cameron",n},"Median"],{n,20}]

MetricDimension

seq=Table[GraphData[{"Cameron",n},"MetricDimension"],{n,20}]

MinimalConnectedDominatingSetCount

seq=Table[GraphData[{"Cameron",n},"MinimalConnectedDominatingSetCount"],{n,20}]

MinimalConnectedDominationPolynomial

Table[GraphData[{"Cameron",n},"MinimalConnectedDominationPolynomial"],{n,20}]/.f_Function:>f[x]

MinimalDominatingSetCount

seq=Table[GraphData[{"Cameron",n},"MinimalDominatingSetCount"],{n,20}]

MinimalDominationPolynomial

(poly=Table[GraphData[{"Cameron",n},"MaximalMatchingGeneratingPolynomial"],{n,20}]/.f_Function:>f[x])//Column

MinimalEdgeCoverCount

seq=Table[GraphData[{"Cameron",n},"MinimalEdgeCoverCount"],{n,20}]

MinimalEdgeCoverPolynomial

(poly=Table[GraphData[{"Cameron",n},"MinimalEdgeCoverPolynomial"],{n,20}]/.f_Function:>f[x])//Column

MinimalEdgeCutCount

seq=Table[GraphData[{"Cameron",n},"MinimalEdgeCutCount"],{n,20}]

MinimalEdgeCutPolynomial

(poly=Table[GraphData[{"Cameron",n},"MinimalEdgeCutPolynomial"],{n,20}]/.f_Function:>f[x])//Column

MinimalTotalDominatingSetCount

seq=Table[GraphData[{"Cameron",n},"MinimalTotalDominatingSetCount"],{n,20}]

MinimalTotalDominationPolynomial

(poly=Table[GraphData[{"Cameron",n},"MinimalTotalDominationPolynomial"],{n,20}]/.f_Function:>f[x])//Column

MinimalVertexCoverCount

seq=Table[GraphData[{"Cameron",n},"MinimalVertexCoverCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

MinimalVertexCoverPolynomial

(poly=Table[GraphData[{"Cameron",n},"MinimalVertexCoverPolynomial"],{n,20}]/.f_Function:>f[x])//Column

MinimalVertexCutCount

seq=Table[GraphData[{"Cameron",n},"MinimalVertexCutCount"],{n,20}]

MinimalVertexCutPolynomial

(poly=Table[GraphData[{"Cameron",n},"MinimalVertexCutPolynomial"],{n,20}]/.f_Function:>f[x])//Column

MinimumCliqueCoveringCount

seq=Table[GraphData[{"Cameron",n},"MinimumCliqueCoveringCount"],{n,20}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"Cameron",n},"MinimumConnectedDominatingSetCount"],{n,20}]

MinimumCoveringsByMaximalCliquesCount

seq=Table[GraphData[{"Cameron",n},"MinimumCoveringsByMaximalCliquesCount"],{n,20}]

MinimumCyclicEdgeCutCount

Inferred for n > 8:

seq=Table[GraphData[{"Cameron",n},"MinimumCyclicEdgeCutCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"Cameron",n},"MinimumDistinguishingLabelingCount"],{n,20}]

MinimumDominatingSetCount

seq=Table[GraphData[{"Cameron",n},"MinimumDominatingSetCount"],{n,20}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"Cameron",n},"MinimumEdgeCoverCount"],{n,20}]

MinimumEdgeCutCount

Inferred for n > 7:

seq=Table[GraphData[{"Cameron",n},"MinimumEdgeCutCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

MinimumLeafNumber

seq=Table[GraphData[{"Cameron",n},"MinimumLeafNumber"],{n,20}]

MinimumPathCoveringCount

seq=Table[GraphData[{"Cameron",n},"MinimumPathCoveringCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

MinimumTotalDominatingSetCount

seq=Table[GraphData[{"Cameron",n},"MinimumTotalDominatingSetCount"],{n,20}]

MinimumVertexCoverCount

seq=Table[GraphData[{"Cameron",n},"MinimumVertexCoverCount"],{n,20}]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

MinimumVertexCutCount

Inferred for n > 7:

seq=Table[GraphData[{"Cameron",n},"MinimumVertexCutCount"],{n,20}]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

MinimumVertexDegree

seq=Table[GraphData[{"Cameron",n},"MinimumVertexDegree"],{n,20}]

MolecularTopologicalIndex

seq=Table[GraphData[{"Cameron",n},"MolecularTopologicalIndex"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]//Factor

Nonhamiltonian

Table[GraphData[{"Cameron",n},"Nonhamiltonian"],{n,20}]

NoPerfectMatching

Table[GraphData[{"Cameron",n},"NoPerfectMatching"],{n,20}]

OddChordlessCycleCount

Inferred for n > 18:

seq=Table[GraphData[{"Cameron",n},"OddChordlessCycleCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

OddChordlessCyclePolynomial

(poly=Table[GraphData[{"Cameron",n},"OddChordlessCyclePolynomial"],{n,20}]/.f_Function:>f[x])//Column

Outerplanar

Table[GraphData[{"Cameron",n},"Outerplanar"],{n,20}]

PageRankCentralities

Tally/@(Table[GraphData[{"Cameron",n},"PageRankCentralities"],{n,20}]/.f_Function:>f[x])//Column

PathCount

seq=Table[GraphData[{"Cameron",n},"PathCount"],{n,20}]

PathCoveringNumber

seq=Table[GraphData[{"Cameron",n},"PathCoveringNumber"],{n,20}]

PathPolynomial

(poly=Table[GraphData[{"Cameron",n},"PathPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x])//Column

PentagonCount

seq=Table[GraphData[{"Cameron",n},"PentagonCount"],{n,20}]

Perfect

Table[GraphData[{"Cameron",n},"Perfect"],{n,20}]

Perfect1FactorizationCount

Table[GraphData[{"Cameron",n},"Perfect1FactorizationCount"],{n,20}]

PerfectlyHamiltonian

Table[GraphData[{"Cameron",n},"PerfectlyHamiltonian"],{n,20}]

PerfectMatching

Table[GraphData[{"Cameron",n},"PerfectMatching"],{n,20}]

Periphery

Table[GraphData[{"Cameron",n},"Periphery"],{n,20}]//Column

PinnacleSetCount

seq=Table[GraphData[{"Cameron",n},"PinnacleSetCount"],{n,20}]

Planar

Table[GraphData[{"Cameron",n},"Planar"],{n,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"Cameron",n},"ProjectivePlaneCrossingNumber"],{n,20}]

Pseudoarboricity

seq=Table[GraphData[{"Cameron",n},"Pseudoarboricity"],{n,20}]

Ptolemaic

seq=Table[GraphData[{"Cameron",n},"Ptolemaic"],{n,20}]

QChromaticPolynomial

(poly=Table[GraphData[{"Cameron",n},"QChromaticPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x])//Column

QuadraticallyEmbeddable

seq=Table[GraphData[{"Cameron",n},"QuadraticallyEmbeddable"],{n,20}]

QuadraticEmbeddingConstant

seq=Table[GraphData[{"Cameron",n},"QuadraticEmbeddingConstant"],{n,20}]

RadialityCentralities

Table[GraphData[{"Cameron",n},"RadialityCentralities"],{n,20}]//Column

RadioLabelingCount

seq=Table[GraphData[{"Cameron",n},"RadioLabelingCount"],{n,20}]

RadioNumber

seq=Table[GraphData[{"Cameron",n},"RadioNumber"],{n,20}]

Radius

seq=Table[GraphData[{"Cameron",n},"Radius"],{n,20}]

FindSequenceFunction[seq,n]

RandicEnergy

Table[GraphData[{"Cameron",n},"RandicEnergy"],{n,20}]

Rank

seq=Table[GraphData[{"Cameron",n},"Rank"],{n,20}]

FindSequenceFunction[seq,n]

RankPolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"RankPolynomial"],{n,k0=1,20}]/.f_Function:>f[x,y])//Column

coef=Factor/@FindLinearRecurrence[poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"Cameron",n},"RectilinearCrossingNumber"],{n,20}]

Regular

Table[GraphData[{"Cameron",n},"Regular"],{n,20}]

RegularParameters

Table[GraphData[{"Cameron",n},"RegularParameters"],{n,20}]//Column

ReliabilityPolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"ReliabilityPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

ResistanceMatrix

MatrixForm/@Table[GraphData[{"Cameron",n},"ResistanceMatrix"],{n,6}]

ScrambleNumber

seq=Table[GraphData[{"Cameron",n},"ScrambleNumber"],{n,20}]

ShannonCapacity

seq=Table[GraphData[{"Cameron",n},"ShannonCapacity"],{n,20}]

SigmaPolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"SigmaPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

SimplexGraphName

Table[GraphData[{"Cameron",n},"SimplexGraphName"],{n,20}]

Singlecross

Table[GraphData[{"Cameron",n},"Singlecross"],{n,20}]

Skewness

seq=Table[GraphData[{"Cameron",n},"Skewness"],{n,20}]

SomborEnergy

Table[GraphData[{"Cameron",n},"SomborEnergy"],{n,20}]

SomborIndex

seq=Table[GraphData[{"Cameron",n},"SomborIndex"],{n,20}]

FindSequenceFunction[seq,n]

SomborSpectralRadius

Inferred for n > 13:

Table[GraphData[{"Cameron",n},"SomborSpectralRadius"],{n,20}]

SpanningTreeCount

seq=Table[GraphData[{"Cameron",n},"SpanningTreeCount"],{n,20}]

FullSimplify[FindSequenceFunction[seq,n],n>0]

gf=x FindGeneratingFunction[seq,x]

SpectralRadius

seq=Table[GraphData[{"Cameron",n},"SpectralRadius"],{n,20}]

SquareCount

seq=Table[GraphData[{"Cameron",n},"SquareCount"],{n,20}]

FindSequenceFunction[seq,n]

SquareFree

Table[GraphData[{"Cameron",n},"SquareFree"],{n,20}]

SquareGraphName

Table[GraphData[{"Cameron",n},"SquareGraphName"],{n,20}]

StabilityIndex

seq=Table[GraphData[{"Cameron",n},"StabilityIndex"],{n,20}]

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

StarArboricity

seq=Table[GraphData[{"Cameron",n},"StarArboricity"],{n,20}]

StatusCentralities

seq=Table[GraphData[{"Cameron",n},"StatusCentralities"],{n,20}]

Strength

seq=Table[GraphData[{"Cameron",n},"Strength"],{n,20}]

StronglyPerfect

Table[GraphData[{"Cameron",n},"StronglyPerfect"],{n,20}]

StronglyRegular

Table[GraphData[{"Cameron",n},"StronglyRegular"],{n,20}]

Switchable

Table[GraphData[{"Cameron",n},"Switchable"],{n,20}]

Symmetric

Table[GraphData[{"Cameron",n},"Symmetric"],{n,20}]

SymmetricallyDistinctVertexPairCount

seq=Table[GraphData[{"Cameron",n},"SymmetricallyDistinctVertexPairCount"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]

Thickness

seq=Table[GraphData[{"Cameron",n},"Thickness"],{n,20}]

TopologicalIndex

seq=Table[GraphData[{"Cameron",n},"TopologicalIndex"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

ToroidalCrossingNumber

seq=Table[GraphData[{"Cameron",n},"ToroidalCrossingNumber"],{n,20}]

TotalDominatingSetCount

seq=Table[GraphData[{"Cameron",n},"TotalDominatingSetCount"],{n,20}]

FindSequenceFunction[seq,n]

TotalDominationNumber

seq=Table[GraphData[{"Cameron",n},"TotalDominationNumber"],{n,20}]

gf=x FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]

TotalDominationPolynomial

(poly=Table[GraphData[{"Cameron",n},"TotalDominationPolynomial"],{n,20}]/.f_Function:>f[x])//Column

Toughness

seq=Table[GraphData[{"Cameron",n},"Toughness"],{n,20}]

Traceable

Table[GraphData[{"Cameron",n},"Traceable"],{n,20}]

TreeDepth

seq=Table[GraphData[{"Cameron",n},"TreeDepth"],{n,20}]

TreeNumber

seq=Table[GraphData[{"Cameron",n},"TreeNumber"],{n,20}]

Treewidth

seq=Table[GraphData[{"Cameron",n},"Treewidth"],{n,20}]

Triameter

seq=Table[GraphData[{"Cameron",n},"Triameter"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

Simplify[SeriesCoefficient[gf,{x,0,n}],n>7]

TriangleCount

seq=Table[GraphData[{"Cameron",n},"TriangleCount"],{n,20}]

TriangleFree

Table[GraphData[{"Cameron",n},"TriangleFree"],{n,20}]

TuttePolynomial

(Table[GraphData[{"Cameron",n},"TuttePolynomial"],{n,20}]/.f_Function:>f[x,y])//Column

Unicyclic

seq=Table[GraphData[{"Cameron",n},"Unicyclic"],{n,20}]

UniquelyColorable

seq=Table[GraphData[{"Cameron",n},"UniquelyColorable"],{n,20}]

UniquelyPancyclic

seq=Table[GraphData[{"Cameron",n},"UniquelyPancyclic"],{n,20}]

UnitDistance

seq=Table[GraphData[{"Cameron",n},"UnitDistance"],{n,20}]

UpperDominationNumber

seq=Table[GraphData[{"Cameron",n},"UpperDominationNumber"],{n,20}]

UpperIrredundanceNumber

seq=Table[GraphData[{"Cameron",n},"UpperIrredundanceNumber"],{n,20}]

VertexConnectivity

Table[GraphData[{"Cameron",n},"VertexConnectivity"],{n,20}]

VertexCount

seq=Table[GraphData[{"Cameron",n},"VertexCount"],{n,20}]

FindSequenceFunction[seq,n]

VertexCoverCount

seq=Table[GraphData[{"Cameron",n},"VertexCoverCount"],{n,20}]

FindSequenceFunction[seq,n]

x FindGeneratingFunction[DeleteMissing@seq,x]

VertexCoverNumber

seq=Table[GraphData[{"Cameron",n},"VertexCoverNumber"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]

VertexCoverPolynomial

(poly=Table[GraphData[{"Cameron",n},"VertexCoverPolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

VertexCutCount

seq=Table[GraphData[{"Cameron",n},"VertexCutCount"],{n,20}]

VertexDegreePolynomial

(poly=Factor@Table[GraphData[{"Cameron",n},"VertexDegreePolynomial"],{n,k0=1,20}]/.f_Function:>f[x])//Column

VertexDegrees

Tally/@Table[GraphData[{"Cameron",n},"VertexDegrees"],{n,20}]//Column

VertexTransitive

seq=Table[GraphData[{"Cameron",n},"VertexTransitive"],{n,20}]

WeisfeilerLemanDimension

seq=Table[GraphData[{"Cameron",n},"WeisfeilerLemanDimension"],{n,20}]

WienerIndex

seq=Table[GraphData[{"Cameron",n},"WienerIndex"],{n,20}]

FindSequenceFunction[seq,n]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

WienerSumIndex

seq=Table[GraphData[{"Cameron",n},"WienerSumIndex"],{n,20}]

Construction

"TwistedEmbedding"

Eric Weisstein, Aug 26, 2025

4 :

5:

CameronGraphTwisted[1]

CameronGraphTwisted[5]

Table[CameronGraph[n,GraphLayout->"TwistedEmbedding"],{n,7}]

"KnuthConstruction"

cameron=Table[CameronPlanarHamiltonianGraph[n],{n,6}]

RecognizeGraph/@cameron

Length[FindHamiltonianCycle[#,All]]&/@cameron

PlanarGraphQ/@cameron

HalinGraphQ/@CanonicalGraph/@cameron

PerfectlyHamiltonianGraphQ/@cameron

GroupOrder[GraphAutomorphismGroup[#]]&/@cameron

GraphAutomorphismGroup[cameron[[2]]]

PermutationList[#,18]&/@GroupElements[GraphAutomorphismGroup[cameron[[2]]]]

PermutationList[#,18]&/@GroupElements[GraphAutomorphismGroup[cameron[[2]]]]/.Thread[Range[18]->VertexList[cameron[[2]]]]

Sources

Cameron

Cameron, K.  "Thomason's algorithm for finding a second hamiltonian circuit through a given edge in a cubic graph is exponential on Krawczyk's graphs".  Discrete Math. 235, 69–77, 2001. https://doi.org/10.1016/S0012-365X(00)00260-0

Knuth

Knuth, D.~E.  ``Hamiltonian Paths and Cycles.''  Volume 4, Pre-Fascicle 8A in {\it The Art of Computer Programming.}  Draft, p.~17 and Exercise 120, Aug.~19, 2025.
 https://www-cs-faculty.stanford.edu/~knuth/fasc8a.ps.gz

GraphData

GraphDataClassString

GraphDataClassString["Cameron"]

GraphDataString

<<MathWorld`Graphs`

file=OpenAppend["~/cameron.m"]

Do[WriteString[file,
GraphDataString[CameronGraph[n],
"StandardName"->{"Cameron",n},
"Name"->ToString[n]<>"\[Hyphen]Cameron cubic planar graph",
"Classes"->{"Cameron","UnitDistance"},
"NotationRules"->{"Cameron"->n},
"Information"->"CameronGraph",
"Skip"->{"ABCEnergy","Arboricity","ArithmeticGeometricEnergy","Bandwidth","BurningNumber","ChordlessCycles","ConnectedInducedSubgraphPolynomial","ConnectedInducedSubgraphs","ConstructionNumber","CoolingNumber","CyclePolynomial","DetourMatrix","DominatingSets","EdgeCovers","Energy","ErdosSequence","GracefulLabeling","HamiltonConnected","HamiltonianPaths","IdiosyncraticPolynomial","IndependencePolynomial","IndependentEdgeSets","IndependentVertexSets","IntersectionNumber","IrredundancePolynomial","MatchingGeneratingPolynomial","MaximalIndependencePolynomial","MaximalIndependentEdgeSets","MaximalIndependentVertexSet","MaximalIndependentVertexSets","MaximumIndependentEdgeSets","MaximumIndependentVertexSets","MetricDimension","MinimumConnectedDominatingSet","MinimumCoveringsByMaximalCliques","MinimumCyclicEdgeCuts","MinimumDominatingSets","MinimumEdgeCuts","MinimumPathCoverings","MinimumTotalDominatingSets","MinimumVertexColorings","MinimumVertexCuts","MinimumWeightFractionalEdgeColoring","Minors","OddChordlessCyclePolynomial","OddChordlessCycles","PathPolynomial","Paths","Pathwidth","Perfect1Factorizations","QuadraticEmbeddingConstant","RandicEnergy","SomborEnergy","TotalDominationPolynomial","TuttePolynomial"},
TimeConstraint->10
]],{n,20,20}]

Close[file]