Fully Forested Graph

Author

Eric W. Weisstein
February 5, 2025

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

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

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

Code

FullyForestedGraphQ[g_Graph,n_]:=AllTrue[Trees[n],IsomorphicSubgraphQ[#,g]&]

Clear[SmallestFullyForestedGraphs

SmallestFullyForestedGraphs[n_Integer?Positive]:=Module[
{
m={0,1,2,4,6,8,11,13,16,18}[[n]]
},
Select[
Graphs[n],
And[
EdgeCount[#]==m,
FullyForestedGraphQ[#,n]
]&
]
]/;n<11

minimal (i.e., not still can't remove any edges while still containing all trees)

MinimalSmallestFullyForestedGraphs[n_Integer?Positive]:=Module[{smallest=SmallestFullyForestedGraphs[n]},
Pick[smallest,MinimalGraphQ[#,smallest]&/@smallest]
]

MinimalGraphQ[g_Graph,l_List]:=Module[
{
subg=Union[CanonicalGraph[Graph[#]]&/@Subsets[EdgeList[g]]],cg=CanonicalGraph/@Select[l,EdgeCount[#]<EdgeCount[g]&]
},
DisjointQ[subg,cg]
]

Sources

Chung and Graham 1978

Question 1:

From Chung and Graham (1978): "Note that all examples given thus far for optimal elements of 𝒮((Subscript[𝒯, n])) have just n+1 vertices, the minimum number possible. Whether this always
happens is not known."  The following code only checks n-node graphs, so assumes so.

where n is the edge count of the tree; but OEIS and MW consider the et of trees with n vertices

Agrees with A004401

<<MathWorld`Graphs`

BFileSequence[004401]

Table[2n-4,{n,10}]

Note (SuperStar[G])(3) is erroneous since it does not contain (Subscript[P, 3])

Chung et al. 1976

Chung, F.~R.~K.; Graham, R.~L.; and Pippenger, N.  ``On Graphs Which Contain All Small Trees. II.''  {\it Colloq.\ Math.\ Soc.\ Janos Bolyai} {\bf 18}, 213--223, 1976.

https://scholarship.claremont.edu/cgi/viewcontent.cgi?article=2050&context=hmc_fac_pub

Minimum number of edges in a *tree* containing containing all trees with n edges

{1,2,4,6,9,13,17}

Possibly not in OEIS?

https://oeis.org/search?q=1%2c2%2c4%2c6%2c9%2c13%2c17

But that minus 1 matches

https://oeis.org/search?q=0%2C1%2C3%2C5%2C8%2C12%2C16&go=Search

https://oeis.org/A000212

{1,2,4,6,9,13,17}-1

Table[Floor[n^2/3],{n,10}]

Figures

Example

GraphicsRow[trees=HighlightGraph[#,EdgeList[#]]&/@(Annotate[#,{VertexSize->{"Scaled",.04},VertexStyle->Black,EdgeStyle->Gray}]&/@Trees[6]),Dividers->All]

g=GraphData[{"SmallestFullyForested",{6,1}}]

GraphicsRow[forestedgraphs=HighlightGraph[Annotate[g,{VertexSize->.07,VertexStyle->Black,EdgeStyle->Gray}],#]&/@(EdgeList@@FindIsomorphicSubgraph[g,#]&/@trees)]

GraphicsGrid[{trees,forestedgraphs},Dividers->All]

Fully n-forested

LabeledGraphDataGraph[r_?DataPaclets`GraphDataDump`MyGraphQ]:=Module[{not,lab,std,},
lab=Which[
!MissingQ[not=GraphData[r,"Notation"]/.s_String?(StringMatchQ[#,LetterCharacter]&):>Style[s,Italic]],
	not,
True,
	Style[StringReplace[GraphData[r,"Name"],"smallest "|" graph"->""],Italic]
];
StyleGraphs[GraphData[r],PlotLabel->Style[lab,Directive[14,Black,FontFamily->"Times New Roman"]]]
]

LabeledGraphDataGraph[g_Graph]:=LabeledGraphDataGraph[RecognizeGraph[g]]

smallest=SplitBy[SortBy[DeleteCases[{GraphData[#,"NotationRules","SmallestFullyForested"],#}&/@GraphData["SmallestFullyForested"],{_Missing,_}],First],#[[1,1]]&][[All,All,2]]

GraphicsGrid[Map[LabeledGraphDataGraph,Take[smallest,7],{2}],Dividers->{{Thick,{True},Thick},Thick},Alignment->Top,ItemAspectRatio->1,ImageSize->800]

Counts

smallest=SplitBy[SortBy[DeleteCases[{GraphData[#,"NotationRules","SmallestFullyForested"],#}&/@GraphData["SmallestFullyForested"],{_Missing,_}],First],#[[1,1]]&][[All,All,2]]

A004401

cnts=BFileSequence[4401]

cnts==(GraphData[#,"EdgeCount"]&/@smallest[[All,1]])

Bound from Chung and Graham (1978)

Table[2n-4,{n,10}]

A380740

BFileSequence[380740]==(Length/@smallest)

Tally[Sort[GraphData["SmallestFullyForested","V"]]]

%[[All,2]]

Compute

Preload

<<MathWorld`Graphs`

Preload trees:

Do[Print[{n,Length[Trees[n]]//Timing}],{n,7,8}]

Preload graphs:

Do[Print[{n,Length[Graphs[n]]//Timing}],{n,10}]

1-6 nodes

Do[Print[{n,SmallestFullyForestedGraphs[n]//Timing}],{n,6}]

7 nodes

GraphData["SmallestFullyForested",7]

GraphData/@%//StyleGraphs

smallest7=SmallestFullyForestedGraphs[7]

Tally[EdgeCount/@smallest7]

GraphIndex/@smallest7

RecognizeGraph/@smallest7

Select[GraphData[7],!FreeQ[GraphData[#,"NotationRules"],"SmallestFullyForested"]&]

MinimalGraphQ[#,smallest7]&/@smallest7

FullyForestedGraphQ[#,7]&/@smallest7

FullyForestedGraphQ[#,8]&/@smallest7

Chung and Graham 1978

v={{270,190},{274,236},{205,213},{155,267},{95,267},{130,212},{127,176}};
g=Graph[Range@Length@v,UndirectedEdge@@@{e[7,3,2,1,3,4,6,5,3,6,7],{4,5}},VertexCoordinates->v,VertexLabels->Automatic]

GraphIndex@g

8 nodes

GraphData["SmallestFullyForested",8]

GraphData/@%//StyleGraphs

Length[smallest8=SmallestFullyForestedGraphs[8]]//Timing

smallest8

FirstPosition[smallest8,_?(IsomorphicGraphQ[#,g]&)]

RecognizeGraph/@smallest8

Tally[EdgeCount/@smallest8]

GraphIndex/@smallest8

FullyForestedGraphQ[#,8]&/@smallest8

FullyForestedGraphQ[#,9]&/@smallest8

Chung and Graham 1978

v={{690,212},{630,210},{629,153},{582,161},{548,191},{547,234},{581,259},{630,279}};
g8=Graph[Range@Length@v,UndirectedEdge@@@{e[1,2,8,7,6,5,4,3,2,7,4,2],e[5,2,6]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g8

FirstPosition[smallest8,_?(IsomorphicGraphQ[#,g8]&)]

9 nodes

GraphData["SmallestFullyForested",9]

GraphData/@%//StyleGraphs

Length[smallest9=SmallestFullyForestedGraphs[9]]//Timing

smallest9

RecognizeGraph/@smallest9

Tally[EdgeCount/@smallest9]

GraphIndex/@smallest9

FullyForestedGraphQ[#,9]&/@smallest9

FullyForestedGraphQ[#,10]&/@smallest9

Import["https://oeis.org/A004401/a004401.png"]

v={{385,58},{278,75},{515,253},{405,189},{285,258},{389,377},{258,451},{125,386},{65,267}};
g9=Graph[Range@Length@v,UndirectedEdge@@@{e[2,1,4,5,6,7,8,9,5,3],e[8,5,7],e[2,5,1],e[2,4,6],{4,3}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g9

FirstPosition[smallest9,_?(IsomorphicGraphQ[#,g9]&)]

10 nodes

GraphData["SmallestFullyForested",10]

GraphData/@%//StyleGraphs

Length[smallest10=SmallestFullyForestedGraphs[10]]//Timing

smallest10

RecognizeGraph/@smallest10

Tally[EdgeCount/@smallest10]

GraphIndex/@smallest10

FullyForestedGraphQ[#,10]&/@smallest10

FullyForestedGraphQ[#,11]&/@smallest10

Import["https://oeis.org/A004401/a004401_1.png"]

v={{187,20},{253,132},{139,106},{187,203},{369,217},{329,298},{240,266},{113,360},{108,249},{18,241}};
g10=Graph[Range@Length@v,UndirectedEdge@@@{e[1,4,3,1],e[9,10,4,8,9,4,2,3,9,7,6,4,5,6],e[2,7,4]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g10

FirstPosition[smallest10,_?(IsomorphicGraphQ[#,g10]&)]

Embeddings

<<MathWorld`Graphs`

GraphData["SmallestFullyForested"]

{"SmallestFullyForested", {1, 1}} == "SingletonGraph"

Names

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

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

{"SmallestFullyForested", {2, 1}} == {"Path", 2}

Names

GraphData[{"SmallestFullyForested",{2,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{2,1}},"StandardNames"]

{"SmallestFullyForested", {3, 1}} == {"Path", 3}

Names

GraphData[{"SmallestFullyForested",{3,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{3,1}},"StandardNames"]

{"SmallestFullyForested", {4, 1}} == "PawGraph"

Names

GraphData[{"SmallestFullyForested",{4,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{4,1}},"StandardNames"]

{"SmallestFullyForested", {5, 1}} == "DartGraph"

Names

GraphData[{"SmallestFullyForested",{5,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{5,1}},"StandardNames"]

{"SmallestFullyForested", {5, 2}} == "ButterflyGraph"

Names

GraphData[{"SmallestFullyForested",{5,2}},"StandardName"]

GraphData[{"SmallestFullyForested",{5,2}},"StandardNames"]

{"SmallestFullyForested", {6, 1}} == {"Matchstick", {8, 4}}

Names

GraphData[{"SmallestFullyForested",{6,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{6,1}},"StandardNames"]

{"SmallestFullyForested", {6, 2}} == {"Matchstick", {8, 1}}

Names

GraphData[{"SmallestFullyForested",{6,2}},"StandardName"]

GraphData[{"SmallestFullyForested",{6,2}},"StandardNames"]

{"SmallestFullyForested", {7, 1}}

Names

GraphData[{"SmallestFullyForested",{7,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{7,1}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{7,1}}]]

Default embedding

RotateGraph[GraphPlot[Graph[GraphData[{"SmallestFullyForested",{7,1}},"VertexList"],GraphData[{"SmallestFullyForested",{7,1}},"Edges"]]],-Pi/2]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

RotateGraph[GraphPlot[Graph[GraphData[{"SmallestFullyForested",{7,1}},"VertexList"],GraphData[{"SmallestFullyForested",{7,1}},"Edges"]],GraphLayout->"RadialEmbedding"],-2Pi/3+Pi]

v=Join[Subdivide[{-1,0},{1,0},3],{{0,Sqrt[3]},{0,Sqrt[3]+1}}];
AppendTo[v,Mean[v[[{2,3,5}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

RotateGraph[,-.1]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{7,1}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{7,1}},"LCF"]

GraphData[{"SmallestFullyForested",{7,1}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{7,1}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{7,1}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{7,1}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{7,1}},{"RCN","CN"}]

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{7,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{7,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{7,1}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{7,1}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestFullyForested",{7,1}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{7,1}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{7,1}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{7,1}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{7,1}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{7,1}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{7,1}},"LCF"]

GraphData[{"SmallestFullyForested",{7,1}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{7,1}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{7,1}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{7,1}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{7,1}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestFullyForested",{7,1}},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{7,1}},"Polyhedral"]

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

{"SmallestFullyForested", {7, 2}} == {"KTree", {2, {7, 4}}}

Names

GraphData[{"SmallestFullyForested",{7,2}},"StandardName"]

GraphData[{"SmallestFullyForested",{7,2}},"StandardNames"]

{"SmallestFullyForested", {7, 3}}

Names

GraphData[{"SmallestFullyForested",{7,3}},"StandardName"]

GraphData[{"SmallestFullyForested",{7,3}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{7,3}}]]

Default embedding

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

RotateGraph[,-1.35]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{7,3}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{7,3}},"LCF"]

GraphData[{"SmallestFullyForested",{7,3}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{7,3}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{7,3}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{7,3}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{7,3}},{"RCN","CN"}]

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{7,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{7,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{7,3}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{7,3}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestFullyForested",{7,3}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{7,3}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{7,3}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{7,3}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{7,3}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{7,3}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{7,3}},"LCF"]

GraphData[{"SmallestFullyForested",{7,3}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{7,3}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{7,3}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{7,3}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

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

Matchstick

GraphData[{"SmallestFullyForested",{7,3}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestFullyForested",{7,3}},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{7,3}},"Polyhedral"]

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

{"SmallestFullyForested", {7, 4}}

Names

GraphData[{"SmallestFullyForested",{7,4}},"StandardName"]

GraphData[{"SmallestFullyForested",{7,4}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{7,4}}]]

Default embedding

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

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

RotateGraph[,Pi]

s=Sqrt[3]/2;
g=FindCorrespondingGraph[,{{0,0},{1,0},{2,0},{1,-1},{2,-1},{1/2,s},{3/2,s}}]

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{7,4}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{7,4}},"LCF"]

GraphData[{"SmallestFullyForested",{7,4}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{7,4}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{7,4}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{7,4}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{7,4}},{"RCN","CN"}]

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{7,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{7,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{7,4}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{7,4}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestFullyForested",{7,4}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{7,4}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{7,4}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{7,4}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{7,4}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{7,4}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{7,4}},"LCF"]

GraphData[{"SmallestFullyForested",{7,4}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{7,4}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{7,4}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{7,4}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{7,4}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestFullyForested",{7,4}},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{7,4}},"Polyhedral"]

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

{"SmallestFullyForested", {7, 5}}

Names

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

GraphData[{"SmallestFullyForested",{7,5}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{7,5}}]]

Default embedding

RotateGraph[GraphPlot[Graph[GraphData[{"SmallestFullyForested",{7,5}},"VertexList"],GraphData[{"SmallestFullyForested",{7,5}},"Edges"]]],-.5]

v={{0,0},{-1,1},{0,1},{1,1},{-1,2},{0,2},{1,2}};
g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

RotateGraph[,-2.95]

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

RecognizeGraph@g

GraphPlot@RotateGraph[,.3]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,-Pi/4]

v=CirclePoints[{1,Pi/2},4];
v=Join[v,{v[[3]]-{0,1/2}},Subdivide[v[[2]],v[[4]],3][[2;;-2]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{7,5}},"Hamiltonian"]

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

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

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{7,5}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{7,5}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{7,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{7,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

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

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

Circulant construction

GraphData[{"SmallestFullyForested",{7,5}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

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

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestFullyForested",{7,5}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{7,5}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{7,5}}]]

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{7,5}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestFullyForested",{7,5}},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{7,5}},"Polyhedral"]

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

{"SmallestFullyForested", {7, 6}} == {"KTree", {2, {7, 6}}}

Names

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

GraphData[{"SmallestFullyForested",{7,6}},"StandardNames"]

{"SmallestFullyForested", {7, 7}} == {"Fan", {1, 6}}

Names

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

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

{"SmallestFullyForested", {8, 1}}

Names

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

GraphData[{"SmallestFullyForested",{8,1}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,1}}]]

Default embedding

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

RotateGraph[,Pi/2]

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

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=RotateGraph[FindCorrespondingGraph[,v],Pi]

RecognizeGraph@g

gs=UnlabelGraph/@{,,,}

GraphPlot@RotateGraph[,-1.1]

GraphReplot@

s=Sqrt[3]/2;
v=Join[{{0,0},{1,0},{2,0},{3/2,s}},Rest@Subdivide[{1/2,0},{1/2,s},4]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

s=Sqrt[3]/2;
v=UnitCirclePoints[4,0];
v=Join[v,{v[[3]]+{-s,1/2},v[[3]]+{-s,-1/2},UnitDistancePoint@@v[[{2,3}]],UnitDistancePoint@@v[[{3,4}]]}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,1}},"Hamiltonian"]

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

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

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,1}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,1}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

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

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,1}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,1}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,1}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,1}}]]

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"SmallestFullyForested", {8, 2}}

Names

GraphData[{"SmallestFullyForested",{8,2}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,2}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,2}}]]

Default embedding

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

GraphPlot@RotateGraph[,-.5]

s=Sqrt[3]/2;
v=Join[{{0,0},{1,0},{2,0},{1/2,-s},{3/2,-s}},Rest@Subdivide[{1/2,0},{1/2,s},3]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,Pi/2]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,};

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,2}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{8,2}},"LCF"]

GraphData[{"SmallestFullyForested",{8,2}},"HamiltonianCycleCount"]

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,2}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,2}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{8,2}},{"RCN","CN"}]

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{8,2}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,2}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,2}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,2}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,2}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{8,2}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{8,2}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{8,2}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{8,2}},"LCF"]

GraphData[{"SmallestFullyForested",{8,2}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{8,2}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{8,2}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{8,2}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{8,2}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{8,2}},"Polyhedral"]

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

{"SmallestFullyForested", {8, 3}} == {"KTree", {2, {8, 10}}}

Names

GraphData[{"SmallestFullyForested",{8,3}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,3}},"StandardNames"]

{"SmallestFullyForested", {8, 4}}

Names

GraphData[{"SmallestFullyForested",{8,4}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,4}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,4}}]]

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,4}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{8,4}},"LCF"]

GraphData[{"SmallestFullyForested",{8,4}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{8,4}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,4}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,4}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{8,4}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,4}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,4}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,4}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,4}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{8,4}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{8,4}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{8,4}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{8,4}},"LCF"]

GraphData[{"SmallestFullyForested",{8,4}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{8,4}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{8,4}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{8,4}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{8,4}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{8,4}},"Polyhedral"]

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

{"SmallestFullyForested", {8, 5}}

Names

GraphData[{"SmallestFullyForested",{8,5}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,5}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,5}}]]

Default embedding

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

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,-.4]

v=Join[CirclePoints[{1,Pi/2},6],{{0,0}}];
AppendTo[v,Mean[v[[{1,2,7}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,-.4]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,-.6]

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{0,-1},{1/2,s}};
v=Join[v,Rest@Subdivide[{-1/2,0},{-1/2,s},3]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

RotateGraph[,.2]

s=Sqrt[3]/2;
v={{0,0},{1,0},{1,1},{0,1},{-s,1/2},{1/2,-s}};
AppendTo[v,UnitDistancePoint@@v[[{5,1}]]];
AppendTo[v,Normalize@Mean[v[[{6,7}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Quit

gs={,,,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,5}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{8,5}},"LCF"]

GraphData[{"SmallestFullyForested",{8,5}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{8,5}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,5}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,5}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{8,5}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,5}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,5}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,5}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,5}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{8,5}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{8,5}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{8,5}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{8,5}},"LCF"]

GraphData[{"SmallestFullyForested",{8,5}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{8,5}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{8,5}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{8,5}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{8,5}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{8,5}},"Polyhedral"]

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

{"SmallestFullyForested", {8, 6}}

Names

GraphData[{"SmallestFullyForested",{8,6}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,6}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,6}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{8,6}},"VertexList"],GraphData[{"SmallestFullyForested",{8,6}},"Edges"],GraphLayout->"SpringEmbedding"]]

s=Sqrt[3]/2;
v=Join[CirclePoints[{1,Pi/2},6],{{0,0}}];
AppendTo[v,Mean[v[[{2,3,7}]]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

v=Join[{{-1,0},{-1,1},{0,0},{0,-1},{1,0}},Subdivide[{0,1},{1,1},2]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,3]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,6}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{8,6}},"LCF"]

GraphData[{"SmallestFullyForested",{8,6}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{8,6}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,6}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,6}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{8,6}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,6}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,6}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,6}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,6}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{8,6}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{8,6}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{8,6}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{8,6}},"LCF"]

GraphData[{"SmallestFullyForested",{8,6}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{8,6}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{8,6}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{8,6}},"UnitDistance"]

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{8,6}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{8,6}},"Polyhedral"]

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

{"SmallestFullyForested", {8, 7}} == {"KTree", {2, {8, 12}}}

Names

GraphData[{"SmallestFullyForested",{8,7}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,7}},"StandardNames"]

{"SmallestFullyForested", {8, 8}}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

s=Sqrt[3]/2;
v={{0,0},{1,0},{1,1},{0,1},{0,-1}};
v=Join[v,Most@Subdivide[{-s,1/2},{0,1/2},3]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

RecognizeGraph/@gs

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

Planar construction

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

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

PlanarGraphEmbeddings

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

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

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

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

MinimalRectilinearLocalCrossing

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

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

Circulant

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

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,8}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{8,8}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{8,8}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"SmallestFullyForested", {8, 9}}

Names

GraphData[{"SmallestFullyForested",{8,9}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,9}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,9}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{8,9}},"VertexList"],GraphData[{"SmallestFullyForested",{8,9}},"Edges"],GraphLayout->"HighDimensionalEmbedding"]]

RotateGraph[,-Pi/2]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

GraphPlot@RotateGraph[,-1.2]

v=Join[{{-1,0},{1,0},{0,Sqrt[3]},{0,Sqrt[3]+1}},Subdivide[{-1/2,1/2},{1/2,1/2},2]];
AppendTo[v,Mean[v[[{3,5,6}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,9}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{8,9}},"LCF"]

GraphData[{"SmallestFullyForested",{8,9}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{8,9}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,9}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,9}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{8,9}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,9}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{8,9}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{8,9}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,9}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,9}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,9}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{8,9}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{8,9}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{8,9}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{8,9}},"LCF"]

GraphData[{"SmallestFullyForested",{8,9}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{8,9}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{8,9}},"LCFNotations"]

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{8,9}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{8,9}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{8,9}},"Polyhedral"]

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

{"SmallestFullyForested", {8, 10}} == {"KTree", {2, {8, 18}}}

Names

GraphData[{"SmallestFullyForested",{8,10}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,10}},"StandardNames"]

{"SmallestFullyForested", {8, 11}}

Names

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

GraphData[{"SmallestFullyForested",{8,11}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,11}}]]

Default embedding

GraphPlot[RotateGraph[Graph[GraphData[{"SmallestFullyForested",{8,11}},"VertexList"],GraphData[{"SmallestFullyForested",{8,11}},"Edges"]],π/2]]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

s=Sqrt[3]/2;
v=CirclePoints[{1,-Pi/2},7];
AppendTo[v,v[[1]]-{0,1}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,.1]

GraphReplot@

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

g=FindCorrespondingGraph[,v]

GraphPlot@RotateGraph[,-.1]

g=FindCorrespondingGraph[,CirclePoints[{1,Pi/2},8]]

gs={,};

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,11}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{8,11}},"LCF"]

GraphData[{"SmallestFullyForested",{8,11}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{8,11}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,11}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,11}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{8,11}},{"RCN","CN"}]

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{8,11}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,11}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{8,11}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{8,11}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,11}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,11}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,11}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{8,11}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{8,11}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{8,11}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{8,11}},"LCF"]

GraphData[{"SmallestFullyForested",{8,11}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{8,11}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{8,11}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"SmallestFullyForested",{8,11}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{8,11}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{8,11}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestFullyForested",{8,11}},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{8,11}},"Polyhedral"]

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

{"SmallestFullyForested", {8, 12}}

Names

GraphData[{"SmallestFullyForested",{8,12}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,12}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{8,12}}]]

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

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

RecognizeGraph@g

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs=UnlabelGraph/@{,,,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{8,12}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{8,12}},"LCF"]

GraphData[{"SmallestFullyForested",{8,12}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{8,12}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{8,12}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{8,12}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{8,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{8,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{8,12}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{8,12}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{8,12}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{8,12}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{8,12}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{8,12}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{8,12}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{8,12}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{8,12}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{8,12}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{8,12}},"LCF"]

GraphData[{"SmallestFullyForested",{8,12}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{8,12}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{8,12}},"LCFNotations"]

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{8,12}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{8,12}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{8,12}},"Polyhedral"]

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

{"SmallestFullyForested", {8, 13}} == {"KTree", {2, {8, 29}}}

Names

GraphData[{"SmallestFullyForested",{8,13}},"StandardName"]

GraphData[{"SmallestFullyForested",{8,13}},"StandardNames"]

{"SmallestFullyForested", {9, 1}}

Names

GraphData[{"SmallestFullyForested",{9,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,1}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,1}}]]

Default embedding

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

s=Sqrt[3]/2;
v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

RotateGraph[,Pi]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,Pi]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

gs={,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{9,1}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,1}},"LCF"]

GraphData[{"SmallestFullyForested",{9,1}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,1}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,1}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,1}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{9,1}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{9,1}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{9,1}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,1}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{9,1}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,1}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{9,1}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{9,1}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{9,1}},"LCF"]

GraphData[{"SmallestFullyForested",{9,1}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,1}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,1}},"LCFNotations"]

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{9,1}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,1}},"Polyhedral"]

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

{"SmallestFullyForested", {9, 2}}

Names

GraphData[{"SmallestFullyForested",{9,2}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,2}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,2}}]]

Default embedding

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

GraphPlot@RotateGraph[,.6]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,Pi]

1/6.

Subdivide[v[[5]],v[[6]],3][[All,1]]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{9,2}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,2}},"LCF"]

GraphData[{"SmallestFullyForested",{9,2}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,2}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,2}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,2}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{9,2}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{9,2}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{9,2}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,2}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{9,2}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,2}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{9,2}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{9,2}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{9,2}},"LCF"]

GraphData[{"SmallestFullyForested",{9,2}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,2}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,2}},"LCFNotations"]

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{9,2}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,2}},"Polyhedral"]

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

{"SmallestFullyForested", {9, 3}}

Names

GraphData[{"SmallestFullyForested",{9,3}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,3}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,3}}]]

Default embedding

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

s=Sqrt[3]/2;
v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,.5]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,1]

v=Append[CirclePoints[{1,Pi/2},6],{0,0}];
v=Join[v,Subdivide[v[[1]],Mean[v[[{6,7}]]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,1.8]

GraphReplot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{9,3}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,3}},"LCF"]

GraphData[{"SmallestFullyForested",{9,3}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,3}},"Planar"]

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,3}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,3}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

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

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{9,3}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{9,3}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{9,3}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,3}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{9,3}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,3}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{9,3}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{9,3}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{9,3}},"LCF"]

GraphData[{"SmallestFullyForested",{9,3}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,3}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,3}},"LCFNotations"]

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{9,3}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,3}},"Polyhedral"]

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

{"SmallestFullyForested", {9, 4}}

Names

GraphData[{"SmallestFullyForested",{9,4}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,4}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,4}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,4}},"VertexList"],GraphData[{"SmallestFullyForested",{9,4}},"Edges"],GraphLayout->"TutteEmbedding"]]

v=CirclePoints[{1,Pi/2},6];
AppendTo[v,Mean[v[[{2,3,4}]]]];
v=Join[v,Subdivide[v[[2]],{0,v[[2,2]]},3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,Pi]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{9,4}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,4}},"LCF"]

GraphData[{"SmallestFullyForested",{9,4}},"HamiltonianCycleCount"]

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,4}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,4}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,4}},{"RCN","CN"}]

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{9,4}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{9,4}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{9,4}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,4}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{9,4}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,4}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{9,4}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{9,4}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{9,4}},"LCF"]

GraphData[{"SmallestFullyForested",{9,4}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,4}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,4}},"LCFNotations"]

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

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

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestFullyForested",{9,4}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,4}},"Polyhedral"]

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

{"SmallestFullyForested", {9, 5}}

Names

GraphData[{"SmallestFullyForested",{9,5}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,5}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,5}}]]

Default embedding

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

GraphPlot@RotateGraph[,-1.2]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphReplot@

v=Join[CirclePoints[{1,Pi/2},4],{{0,0},{1/4,-1/2},{1/2,-1/4},{-1/2,-1/4},{-1/4,-1/2}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

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

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestFullyForested",{9,5}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,5}},"LCF"]

GraphData[{"SmallestFullyForested",{9,5}},"HamiltonianCycleCount"]

Planar

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

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

Planar construction

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

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,5}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,5}},"PlanarEmbeddingCount"]

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

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,5}},{"RCN","CN"}]

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

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

Circulant

GraphData[{"SmallestFullyForested",{9,5}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestFullyForested",{9,5}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestFullyForested",{9,5}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,5}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestFullyForested",{9,5}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,5}},"Halin"]

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

Rigid

GraphData[{"SmallestFullyForested",{9,5}},"Rigid"]

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

Flexible

GraphData[{"SmallestFullyForested",{9,5}},"Flexible"]

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

LCF

GraphData[{"SmallestFullyForested",{9,5}},"LCF"]

GraphData[{"SmallestFullyForested",{9,5}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,5}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,5}},"LCFNotations"]

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

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

UnitDistance

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

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

GraphData[{"SmallestFullyForested",{9,5}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,5}},"VertexList"],GraphData[{"SmallestFullyForested",{9,5}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,5}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,5}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,5}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,5}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,5}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,5}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,5}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,5}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,5}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,5}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 6}}

Names

GraphData[{"SmallestFullyForested",{9,6}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,6}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,6}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,6}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,6}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,6}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,6}},"VertexList"],GraphData[{"SmallestFullyForested",{9,6}},"Edges"]]]

GraphPlot@

v=Join[CirclePoints[{1,Pi/2},6],{{0,0}}];
v=Join[v,Mean[v[[#]]]&/@{{2,3,7},{2,1,7}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=RotateGraph[FindCorrespondingGraph[,v],-3Pi/6]

RecognizeGraph@g

GraphReplot@

s=Sqrt[3]/2;
v=Join[{{0,0},{1/2,s},{1,0},{3/2,s},{2,0},{3/2,5/8}},Subdivide[{5/4+1/8,1/4},{7/4-1/8,1/4},2]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,6}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,6}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,6}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,6}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,6}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,6}},"LCF"]

GraphData[{"SmallestFullyForested",{9,6}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,6}},"Planar"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,6}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,6}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,6}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,6}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,6}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,6}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,6}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,6}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,6}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,6}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,6}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,6}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,6}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,6}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,6}},"Halin"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,6}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,6}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,6}},"LCF"]

GraphData[{"SmallestFullyForested",{9,6}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,6}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,6}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,6}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,6}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,6}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,6}},"VertexList"],GraphData[{"SmallestFullyForested",{9,6}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,6}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,6}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,6}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,6}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,6}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,6}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,6}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,6}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,6}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 7}}

Names

GraphData[{"SmallestFullyForested",{9,7}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,7}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,7}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,7}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,7}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,7}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,7}},"VertexList"],GraphData[{"SmallestFullyForested",{9,7}},"Edges"]]]

s=Sqrt[3]/2;
v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,.5]

s=Sqrt[3]/2;
v=Join[{{0,0},{1,0},{1/2,s},{1+s,1/2},{1+s,-1/2}},Most@Subdivide[{1/2,-s},{1/2,0},3]];
AppendTo[v,Mean[v[[{1,2,3}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[CirclePoints[{1,Pi/2},6],{0,0}];
v=Join[v,Subdivide[v[[3]],Mean[v[[{2,7}]]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=RotateGraph[FindCorrespondingGraph[,v],-Pi/6]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,7}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,7}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,7}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,7}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,7}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,7}},"LCF"]

GraphData[{"SmallestFullyForested",{9,7}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,7}},"Planar"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,7}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,7}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,7}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,7}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,7}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,7}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,7}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,7}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,7}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,7}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,7}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,7}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,7}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,7}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,7}},"Halin"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,7}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,7}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,7}},"LCF"]

GraphData[{"SmallestFullyForested",{9,7}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,7}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,7}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,7}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,7}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,7}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,7}},"VertexList"],GraphData[{"SmallestFullyForested",{9,7}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,7}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,7}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,7}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,7}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,7}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,7}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,7}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,7}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,7}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 8}}

Names

GraphData[{"SmallestFullyForested",{9,8}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,8}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,8}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,8}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,8}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,8}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,8}},"VertexList"],GraphData[{"SmallestFullyForested",{9,8}},"Edges"]]]

GraphPlot@RotateGraph[,.6]

s=Sqrt[3]/2;
v={{0,0},{1,0},{2,0},{1/2,s},{3/2,s}};
v=Join[v,Subdivide[{3/2,0},{3/2,s},5][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

GraphPlot@RotateGraph[,.8]

s=Sqrt[3]/2;
v={{0,0},{1,0},{1/2,s},{1/2,-s},{1+s,1/2},{1+s,-1/2}};
AppendTo[v,Mean@v[[{1,2,3}]]];
v=Join[v,Subdivide[{1/2,0},{1/2,-s},3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,8}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,8}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,8}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,8}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,8}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,8}},"LCF"]

GraphData[{"SmallestFullyForested",{9,8}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,8}},"Planar"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,8}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,8}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,8}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,8}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,8}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,8}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,8}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,8}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,8}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,8}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,8}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,8}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,8}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,8}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,8}},"Halin"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,8}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,8}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,8}},"LCF"]

GraphData[{"SmallestFullyForested",{9,8}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,8}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,8}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,8}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,8}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,8}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,8}},"VertexList"],GraphData[{"SmallestFullyForested",{9,8}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,8}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,8}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,8}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,8}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,8}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,8}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,8}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,8}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,8}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 9}}

Names

GraphData[{"SmallestFullyForested",{9,9}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,9}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,9}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,9}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,9}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,9}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,9}},"VertexList"],GraphData[{"SmallestFullyForested",{9,9}},"Edges"],GraphLayout->"TutteEmbedding"]]

s=Sqrt[3]/2;
v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

s=Sqrt[3]/2;
v={{-1/2,0},{1/2,0},{-1,s},{0,s},{1,s},{-1/8,1/4},{1/8,1/4}};
v=Join[v,Mean[v[[#]]]&/@{{1,3,4},{2,4,5}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

s=Sqrt[3]/2;
v={{-1/2,0},{1/2,0},{-1,s},{0,s},{1,s}};
AppendTo[v,Mean[v[[{2,4,5}]]]];
v=Join[v,Subdivide[{-1/4+1/16,1/4},{1/4-+1/16,1/4},2]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[Drop[CirclePoints[{1,Pi/2},6],{4}],{0,0}];
v=Join[v,{Mean[v[[{2,3,6}]]]},Subdivide[Mean[v[[{1,6}]]],v[[5]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

RotateGraph[,Pi]

GraphPlot@

v=Join[{{-1,0},{1,0},{0,Sqrt[3]}},Subdivide[{-1/2,1/4},{1/2,1/4},4]];
AppendTo[v,Mean[v[[{3,6,7}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,,}

RecognizeGraph/@gs

Degenerate

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,9}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,9}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,9}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,9}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,9}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,9}},"LCF"]

GraphData[{"SmallestFullyForested",{9,9}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,9}},"Planar"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,9}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,9}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,9}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,9}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,9}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,9}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,9}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,9}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,9}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,9}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,9}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,9}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,9}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,9}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,9}},"Halin"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,9}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,9}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,9}},"LCF"]

GraphData[{"SmallestFullyForested",{9,9}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,9}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,9}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,9}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,9}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,9}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,9}},"VertexList"],GraphData[{"SmallestFullyForested",{9,9}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,9}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,9}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,9}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,9}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,9}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,9}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,9}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,9}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,9}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 10}}

Names

GraphData[{"SmallestFullyForested",{9,10}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,10}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,10}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,10}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,10}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,10}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,10}},"VertexList"],GraphData[{"SmallestFullyForested",{9,10}},"Edges"]]]

GraphPlot@

v=Join[{{0,0},{1/2,0},{1,0},{1,1/2},{1,1},{0,1}},Subdivide[{1/4,3/4},{3/4,3/4},2]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v={{0,0},{1/2,0},{1,0},{1,1/2},{1,1},{0,1},{1/4,3/4},{3/4,3/4},{1/2,1/2}};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

s=Sqrt[3]/2;
v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

RotateGraph[,-.2]

s=Sqrt[3]/2;
v={{0,0},{0,1}};
v=Join[v,Most@Subdivide[{-s,1/2},{0,1/2},3],Rest@Subdivide[{0,1/2},{s,1/2},3]];
AppendTo[v,UnitDistancePoint@@v[[{1,8}]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,10}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,10}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,10}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,10}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,10}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,10}},"LCF"]

GraphData[{"SmallestFullyForested",{9,10}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,10}},"Planar"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,10}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,10}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,10}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,10}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,10}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,10}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,10}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,10}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,10}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,10}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,10}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,10}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,10}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,10}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,10}},"Halin"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,10}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,10}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,10}},"LCF"]

GraphData[{"SmallestFullyForested",{9,10}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,10}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,10}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,10}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,10}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,10}},"VertexList"],GraphData[{"SmallestFullyForested",{9,10}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,10}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,10}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,10}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,10}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,10}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,10}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,10}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 11}}

Names

GraphData[{"SmallestFullyForested",{9,11}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,11}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,11}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,11}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,11}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,11}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,11}},"VertexList"],GraphData[{"SmallestFullyForested",{9,11}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v={{-1/2,0},{1/2,0},{-1,s},{0,s},{1,s},{-1/8,1/4},{1/8,1/4}};
v=Join[v,Mean[v[[#]]]&/@{{1,3,4},{2,4,5}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,.2]

s=Sqrt[3]/2;
v={{-1/2,-s},{1/2,-s},{-1,0},{0,0},{1,0},{0,1},{1,1}};
v=Join[v,Subdivide[Mean[v[[{4,5}]]],v[[2]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

s=Sqrt[3]/2;
v={{-1/2,-s},{1/2,-s},{-1,0},{0,0},{1,0},{1/2,s},{(1/2),(1/(2 (Sqrt[3])))}};
v=Join[v,Subdivide[Mean[v[[{4,5}]]],v[[2]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,11}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,11}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,11}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,11}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,11}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,11}},"LCF"]

GraphData[{"SmallestFullyForested",{9,11}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,11}},"Planar"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,11}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,11}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,11}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,11}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,11}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,11}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,11}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,11}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,11}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,11}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,11}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,11}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,11}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,11}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,11}},"Halin"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,11}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,11}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,11}},"LCF"]

GraphData[{"SmallestFullyForested",{9,11}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,11}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,11}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,11}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,11}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,11}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,11}},"VertexList"],GraphData[{"SmallestFullyForested",{9,11}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,11}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,11}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,11}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,11}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,11}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,11}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,11}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,11}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,11}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 12}}

Names

GraphData[{"SmallestFullyForested",{9,12}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,12}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,12}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,12}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,12}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,12}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,12}},"VertexList"],GraphData[{"SmallestFullyForested",{9,12}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v=Append[Drop[CirclePoints[{1,Pi/2},6],{4}],{0,0}];
v=Join[v,Subdivide[Mean[v[[{1,6}]]],v[[5]],4][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

Mean[v[[{1,4}]]]

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{0,Sqrt[3]},{-1/2,1/4}};
v=Join[v,{Mean[v[[{3,4}]]]},Subdivide[Mean[v[[{1,4}]]],{0,s},4][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,12}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,12}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,12}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,12}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,12}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,12}},"LCF"]

GraphData[{"SmallestFullyForested",{9,12}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,12}},"Planar"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,12}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,12}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,12}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,12}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,12}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,12}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,12}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,12}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,12}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,12}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,12}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,12}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,12}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,12}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,12}},"Halin"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,12}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,12}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,12}},"LCF"]

GraphData[{"SmallestFullyForested",{9,12}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,12}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,12}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,12}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,12}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,12}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,12}},"VertexList"],GraphData[{"SmallestFullyForested",{9,12}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,12}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,12}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,12}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,12}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,12}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,12}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,12}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,12}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,12}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 13}}

Names

GraphData[{"SmallestFullyForested",{9,13}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,13}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,13}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,13}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,13}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,13}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,13}},"VertexList"],GraphData[{"SmallestFullyForested",{9,13}},"Edges"]]]

GraphPlot@RotateGraph[,1.3]

v={{0,0},{1,0},{1,1},{0,1},{1/2,1},{1/2,Sqrt[3]/2+1},{1/2,1/2},{1/4,1/4},{3/4,1/4}};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,-1.1]

v=Join[{{-1,0},{1,0},{0,Sqrt[3]},{0,Sqrt[3]+1/2}},Subdivide[{-1/2,1/4},{1/2,1/4},2]];
v=Join[v,Subdivide[v[[6]],Mean[v[[{3,5}]]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,13}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,13}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,13}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,13}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,13}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,13}},"LCF"]

GraphData[{"SmallestFullyForested",{9,13}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,13}},"Planar"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,13}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,13}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,13}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,13}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,13}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,13}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,13}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,13}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,13}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,13}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,13}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,13}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,13}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,13}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,13}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,13}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,13}},"Halin"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,13}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,13}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,13}},"LCF"]

GraphData[{"SmallestFullyForested",{9,13}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,13}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,13}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,13}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,13}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,13}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,13}},"VertexList"],GraphData[{"SmallestFullyForested",{9,13}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,13}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,13}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,13}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,13}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,13}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,13}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,13}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,13}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,13}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 14}}

Names

GraphData[{"SmallestFullyForested",{9,14}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,14}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,14}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,14}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,14}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,14}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,14}},"VertexList"],GraphData[{"SmallestFullyForested",{9,14}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{-1/2,s}};
AppendTo[v,Mean[v[[{1,2,4}]]]];
v=Join[v,Rest@Subdivide[Mean[v[[{2,3}]]],{1/2,s},4]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

Degenerate

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,14}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,14}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,14}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,14}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,14}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,14}},"LCF"]

GraphData[{"SmallestFullyForested",{9,14}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,14}},"Planar"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,14}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,14}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,14}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,14}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,14}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,14}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,14}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,14}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,14}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,14}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,14}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,14}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,14}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,14}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,14}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,14}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,14}},"Halin"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,14}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,14}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,14}},"LCF"]

GraphData[{"SmallestFullyForested",{9,14}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,14}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,14}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,14}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,14}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,14}},"VertexList"],GraphData[{"SmallestFullyForested",{9,14}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,14}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,14}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,14}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,14}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,14}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,14}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 15}}

Names

GraphData[{"SmallestFullyForested",{9,15}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,15}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,15}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,15}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,15}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,15}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,15}},"VertexList"],GraphData[{"SmallestFullyForested",{9,15}},"Edges"]]]

GraphPlot@RotateGraph[,.4]

v=Join[CirclePoints[5],Subdivide[{-1/4,-1/2},{1/4,-1/2},2]];
AppendTo[v,Mean[v[[{2,4}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

Degenerate

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,15}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,15}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,15}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,15}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,15}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,15}},"LCF"]

GraphData[{"SmallestFullyForested",{9,15}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,15}},"Planar"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,15}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,15}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,15}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,15}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,15}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,15}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,15}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,15}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,15}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,15}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,15}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,15}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,15}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,15}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,15}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,15}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,15}},"Halin"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,15}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,15}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,15}},"LCF"]

GraphData[{"SmallestFullyForested",{9,15}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,15}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,15}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,15}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,15}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,15}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,15}},"VertexList"],GraphData[{"SmallestFullyForested",{9,15}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,15}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,15}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,15}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,15}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,15}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,15}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,15}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,15}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,15}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 16}}

Names

GraphData[{"SmallestFullyForested",{9,16}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,16}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,16}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,16}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,16}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,16}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,16}},"VertexList"],GraphData[{"SmallestFullyForested",{9,16}},"Edges"]]]

GraphPlot@RotateGraph[,Pi]

s=Sqrt[3]/2;
v={{0,0},{1,0},{1/2,s},{1/2,-s},{1+s,1/2},{1+s,-1/2}};
v=Join[v,CirclePoints[Mean[v[[{1,2,3}]]],{1/6,-Pi/2},3]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

s=Sqrt[3]/2;
v={{0,0},{1,0},{1/2,s},{1/2,-s},{2,0},{3/2,s}};
v=Join[v,CirclePoints[Mean[v[[{1,2,3}]]],{1/6,-Pi/2},3]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,16}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,16}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,16}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,16}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,16}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,16}},"LCF"]

GraphData[{"SmallestFullyForested",{9,16}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,16}},"Planar"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,16}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,16}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,16}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,16}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,16}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,16}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,16}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,16}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,16}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,16}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,16}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,16}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,16}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,16}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,16}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,16}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,16}},"Halin"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,16}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,16}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,16}},"LCF"]

GraphData[{"SmallestFullyForested",{9,16}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,16}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,16}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,16}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,16}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,16}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,16}},"VertexList"],GraphData[{"SmallestFullyForested",{9,16}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,16}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,16}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,16}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,16}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,16}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,16}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,16}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,16}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,16}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 17}}

Names

GraphData[{"SmallestFullyForested",{9,17}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,17}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,17}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,17}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,17}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,17}},"VertexList"],GraphData[{"SmallestFullyForested",{9,17}},"Edges"]]]

GraphReplot@

s=Sqrt[3]/2;
v={{-s,-1/2},{-s,1/2},{0,0},{s,-1/2},{s,1/2},{4/5,0},{4/5,-1/3},{1/2,1/8},{1/2,-1/8}};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,17}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,17}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,17}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,17}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,17}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,17}},"LCF"]

GraphData[{"SmallestFullyForested",{9,17}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,17}},"Planar"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,17}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,17}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,17}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,17}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,17}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,17}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,17}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,17}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,17}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,17}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,17}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,17}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,17}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,17}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,17}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,17}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,17}},"Halin"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,17}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,17}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,17}},"LCF"]

GraphData[{"SmallestFullyForested",{9,17}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,17}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,17}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,17}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,17}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,17}},"VertexList"],GraphData[{"SmallestFullyForested",{9,17}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,17}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,17}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,17}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,17}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,17}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,17}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,17}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 18}}

Names

GraphData[{"SmallestFullyForested",{9,18}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,18}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,18}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,18}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,18}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,18}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,18}},"VertexList"],GraphData[{"SmallestFullyForested",{9,18}},"Edges"]]]

GraphPlot@

v=Append[Drop[CirclePoints[{1,Pi/2},6],{4}],{0,0}];
AppendTo[v,Mean[v[[{1,2,6}]]]];
v=Join[v,Subdivide[Mean[v[[{1,6}]]],v[[5]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,-.2]

v=CirclePoints[{1,Pi/2},4];
v=Join[v,Subdivide[v[[2]],{0,0},3][[2;;-2]],Subdivide[{0,0},v[[4]],3][[2;;-2]]];
AppendTo[v,UnitDistancePoint@@v[[{3,4}]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

GraphPlot@RotateGraph[,Pi]

v=Join[{{0,0},{1,0},{1,1},{1/2,1},{0,1}},Subdivide[{1/4,1/4},{3/4,1/4},2]];
AppendTo[v,Mean[v[[{4,6,7}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

s=Sqrt[3]/2;
v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,18}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,18}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,18}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,18}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,18}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,18}},"LCF"]

GraphData[{"SmallestFullyForested",{9,18}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,18}},"Planar"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,18}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,18}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,18}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,18}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,18}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,18}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,18}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,18}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,18}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,18}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,18}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,18}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,18}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,18}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,18}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,18}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,18}},"Halin"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,18}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,18}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,18}},"LCF"]

GraphData[{"SmallestFullyForested",{9,18}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,18}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,18}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,18}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,18}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,18}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,18}},"VertexList"],GraphData[{"SmallestFullyForested",{9,18}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,18}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,18}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,18}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,18}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,18}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,18}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,18}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,18}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,18}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 19}}

Names

GraphData[{"SmallestFullyForested",{9,19}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,19}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,19}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,19}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,19}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,19}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,19}},"VertexList"],GraphData[{"SmallestFullyForested",{9,19}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{-1/2,s},{1/2,s},{-2/3,1/4},{-1/3,1/4},{1/3,1/4},{2/3,1/4}};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Join[{{0,0},{1/2,0},{1,0},{1,1/2},{1,1},{0,1}},Subdivide[{3/8,1/2},{5/8,1/2},2]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

GraphPlot@

v=Append[Drop[CirclePoints[{1,Pi/2},6],{4}],{0,0}];
AppendTo[v,Mean[v[[{1,5,6}]]]];
v=Join[v,Subdivide[Mean[v[[{2,6}]]],v[[1]],3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,19}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,19}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,19}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,19}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,19}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,19}},"LCF"]

GraphData[{"SmallestFullyForested",{9,19}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,19}},"Planar"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,19}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,19}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,19}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,19}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,19}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,19}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,19}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,19}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,19}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,19}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,19}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,19}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,19}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,19}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,19}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,19}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,19}},"Halin"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,19}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,19}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,19}},"LCF"]

GraphData[{"SmallestFullyForested",{9,19}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,19}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,19}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,19}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,19}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,19}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,19}},"VertexList"],GraphData[{"SmallestFullyForested",{9,19}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,19}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,19}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,19}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,19}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,19}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,19}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,19}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,19}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,19}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 20}}

Names

GraphData[{"SmallestFullyForested",{9,20}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,20}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,20}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,20}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,20}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,20}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,20}},"VertexList"],GraphData[{"SmallestFullyForested",{9,20}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{0,Sqrt[3]}};
AppendTo[v,Mean[v[[{3,4}]]]];
v=Join[v,Subdivide[{-1/2,1/2},{0,1/2},3][[;;-2]]];
AppendTo[v,v[[6]]/{1,2}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[CirclePoints[{1,Pi/2},6],{0,0}];
v=Join[v,Mean[v[[#]]]&/@{{1,2,7},{1,6,7}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

s=Sqrt[3]/2;
v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,};

Degenerate

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,20}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,20}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,20}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,20}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,20}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,20}},"LCF"]

GraphData[{"SmallestFullyForested",{9,20}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,20}},"Planar"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,20}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,20}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,20}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,20}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,20}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,20}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,20}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,20}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,20}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,20}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,20}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,20}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,20}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,20}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,20}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,20}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,20}},"Halin"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,20}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,20}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,20}},"LCF"]

GraphData[{"SmallestFullyForested",{9,20}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,20}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,20}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,20}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,20}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,20}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,20}},"VertexList"],GraphData[{"SmallestFullyForested",{9,20}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,20}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,20}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,20}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,20}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,20}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,20}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,20}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,20}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,20}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 21}}

Names

GraphData[{"SmallestFullyForested",{9,21}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,21}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,21}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,21}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,21}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,21}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,21}},"VertexList"],GraphData[{"SmallestFullyForested",{9,21}},"Edges"]]]

GraphPlot@RotateGraph[,2.8]

v=Append[CirclePoints[{1,Pi/2},6],{0,0}];
v=Join[v,Subdivide[v[[2]],{0,1/2},3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

g=;

Degenerate

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,21}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,21}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,21}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,21}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,21}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,21}},"LCF"]

GraphData[{"SmallestFullyForested",{9,21}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,21}},"Planar"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,21}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,21}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,21}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,21}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,21}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,21}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,21}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,21}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,21}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,21}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,21}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,21}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,21}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,21}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,21}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,21}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,21}},"Halin"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,21}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,21}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,21}},"LCF"]

GraphData[{"SmallestFullyForested",{9,21}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,21}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,21}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,21}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,21}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,21}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,21}},"VertexList"],GraphData[{"SmallestFullyForested",{9,21}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,21}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,21}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,21}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,21}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,21}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,21}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,21}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,21}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,21}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 22}}

Names

GraphData[{"SmallestFullyForested",{9,22}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,22}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,22}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,22}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,22}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,22}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,22}},"VertexList"],GraphData[{"SmallestFullyForested",{9,22}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{1/2,s},{-1/2,s},{0,-1}};
AppendTo[v,Mean[v[[{1,2,5}]]]];
v=Join[v,{#/8,3/5}&/@{-1,1}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,22}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,22}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,22}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,22}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,22}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,22}},"LCF"]

GraphData[{"SmallestFullyForested",{9,22}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,22}},"Planar"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,22}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,22}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,22}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,22}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,22}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,22}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,22}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,22}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,22}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,22}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,22}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,22}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,22}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,22}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,22}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,22}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,22}},"Halin"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,22}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,22}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,22}},"LCF"]

GraphData[{"SmallestFullyForested",{9,22}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,22}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,22}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,22}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,22}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,22}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,22}},"VertexList"],GraphData[{"SmallestFullyForested",{9,22}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,22}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,22}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,22}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,22}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,22}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,22}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,22}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,22}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,22}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 23}}

Names

GraphData[{"SmallestFullyForested",{9,23}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,23}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,23}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,23}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,23}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,23}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,23}},"VertexList"],GraphData[{"SmallestFullyForested",{9,23}},"Edges"]]]

GraphPlot@RotateGraph[,2.8]

s=Sqrt[3]/2;
v=Join[{{0,0},{0,1},{0,-1/2},{s,1/2}},Most@Subdivide[{-s,1/2},{0,1/2},4]];
AppendTo[v,Mean[v[[{1,2,4}]]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,-Pi/2]

s=Sqrt[3]/2;
v=Join[CirclePoints[3],CirclePoints[1/2,3]];
v=Join[v,{v[[2]]+{0,1/2}},Mean[v[[#]]]&/@{{5,6},{4,5}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,};

Degenerate

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,23}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,23}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,23}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,23}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,23}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,23}},"LCF"]

GraphData[{"SmallestFullyForested",{9,23}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,23}},"Planar"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,23}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,23}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,23}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,23}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,23}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,23}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,23}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,23}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,23}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,23}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,23}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,23}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,23}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,23}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,23}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,23}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,23}},"Halin"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,23}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,23}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,23}},"LCF"]

GraphData[{"SmallestFullyForested",{9,23}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,23}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,23}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,23}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,23}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,23}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,23}},"VertexList"],GraphData[{"SmallestFullyForested",{9,23}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,23}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,23}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,23}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,23}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,23}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,23}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,23}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,23}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,23}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 24}}

Names

GraphData[{"SmallestFullyForested",{9,24}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,24}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,24}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,24}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,24}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,24}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,24}},"VertexList"],GraphData[{"SmallestFullyForested",{9,24}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v=Append[Drop[CirclePoints[{1, Pi/2},6],{4}],{0,0}];
AppendTo[v,Mean[v[[{2,1,6}]]]];
v=Join[v,Subdivide[{0,1/2},{s,1/2},3][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,24}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,24}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,24}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,24}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,24}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,24}},"LCF"]

GraphData[{"SmallestFullyForested",{9,24}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,24}},"Planar"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,24}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,24}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,24}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,24}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,24}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,24}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,24}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,24}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,24}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,24}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,24}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,24}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,24}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,24}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,24}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,24}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,24}},"Halin"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,24}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,24}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,24}},"LCF"]

GraphData[{"SmallestFullyForested",{9,24}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,24}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,24}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,24}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,24}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,24}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,24}},"VertexList"],GraphData[{"SmallestFullyForested",{9,24}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,24}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,24}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,24}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,24}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,24}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,24}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,24}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,24}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,24}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {9, 25}}

Names

GraphData[{"SmallestFullyForested",{9,25}},"StandardName"]

GraphData[{"SmallestFullyForested",{9,25}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{9,25}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{9,25}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{9,25}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{9,25}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{9,25}},"VertexList"],GraphData[{"SmallestFullyForested",{9,25}},"Edges"]]]

v=Append[CirclePoints[1,6],{0,0}];
v=Join[v,Mean[v[[#]]]&/@{{4,5,7},{2,3,7}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

v=Append[CirclePoints[{1,Pi/2},6],{0,0}];
v=Join[v,Mean[v[[#]]]&/@{{2,3,7},{5,6,7}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{9,25}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{9,25}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{9,25}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{9,25}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{9,25}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{9,25}},"LCF"]

GraphData[{"SmallestFullyForested",{9,25}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{9,25}},"Planar"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,25}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{9,25}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{9,25}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{9,25}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{9,25}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{9,25}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{9,25}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{9,25}},"Circulant"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{9,25}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{9,25}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{9,25}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{9,25}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{9,25}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{9,25}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{9,25}}&]

RootGraph[GraphData[{"SmallestFullyForested",{9,25}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{9,25}},"Halin"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{9,25}},"Rigid"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{9,25}},"Flexible"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{9,25}},"LCF"]

GraphData[{"SmallestFullyForested",{9,25}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{9,25}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{9,25}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{9,25}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{9,25}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{9,25}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{9,25}},"VertexList"],GraphData[{"SmallestFullyForested",{9,25}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{9,25}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,25}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{9,25}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{9,25}},"Matchstick"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{9,25}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{9,25}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{9,25}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{9,25}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{9,25}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 1}}

Names

GraphData[{"SmallestFullyForested",{10,1}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,1}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,1}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,1}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,1}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,1}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,1}},"VertexList"],GraphData[{"SmallestFullyForested",{10,1}},"Edges"]]]

GraphPlot@RotateGraph[,-2.15]

v=Append[CirclePoints[{1,Pi/2},7],{0,0}];
v=Join[v,Mean[v[[#]]]&/@{{1,2,8},{1,7,8}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

v={{-1,0},{0,0},{1,0},{-1,1},{1,1},{0,2},{-1/3,1},{1/3,1},{-1/2,-Sqrt[3]/2},{1/2,-Sqrt[3]/2}};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,1}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,1}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,1}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,1}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,1}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,1}},"LCF"]

GraphData[{"SmallestFullyForested",{10,1}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,1}},"Planar"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,1}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,1}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,1}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,1}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,1}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,1}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,1}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,1}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,1}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,1}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,1}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,1}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,1}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,1}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,1}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,1}},"Halin"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,1}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,1}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,1}},"LCF"]

GraphData[{"SmallestFullyForested",{10,1}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,1}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,1}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,1}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,1}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,1}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,1}},"VertexList"],GraphData[{"SmallestFullyForested",{10,1}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,1}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,1}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,1}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,1}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,1}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,1}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,1}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,1}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,1}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 2}}

Names

GraphData[{"SmallestFullyForested",{10,2}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,2}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,2}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,2}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,2}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,2}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,2}},"VertexList"],GraphData[{"SmallestFullyForested",{10,2}},"Edges"]]]

GraphPlot@RotateGraph[,Pi]

v={{-1,0},{1,0},{0,Sqrt[3]}};
v=Join[v,Subdivide[{-1/2,1/4},{0,1/4},3],Drop[Subdivide[{0,1/4},{1/2,1/4},3],2]];
AppendTo[v,Mean[v[[{3,7,8}]]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

GraphPlot@

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{-1/2,-s},{1/2,-s},{-1/2,s},{-1/4,-2/3},{1/4,-2/3}};
v=Join[v,Mean[v[[#]]]&/@{{7,8,2},{2,5,3}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,};

Degenerate

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,2}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,2}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,2}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,2}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,2}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,2}},"LCF"]

GraphData[{"SmallestFullyForested",{10,2}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,2}},"Planar"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,2}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,2}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,2}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,2}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,2}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,2}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,2}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,2}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,2}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,2}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,2}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,2}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,2}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,2}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,2}},"Halin"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,2}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,2}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,2}},"LCF"]

GraphData[{"SmallestFullyForested",{10,2}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,2}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,2}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,2}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,2}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,2}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,2}},"VertexList"],GraphData[{"SmallestFullyForested",{10,2}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,2}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,2}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,2}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,2}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,2}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,2}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,2}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,2}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,2}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 3}}

Names

GraphData[{"SmallestFullyForested",{10,3}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,3}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,3}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,3}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,3}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,3}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,3}},"VertexList"],GraphData[{"SmallestFullyForested",{10,3}},"Edges"]]]

GraphPlot@RotateGraph[,-2.15]

GraphPlot@

v=Append[Drop[CirclePoints[{1,Pi/2},6],{4}],{0,0}];
v=Join[v,{Mean[v[[{2,3,6}]]]},Subdivide[{0,1/2},v[[5]],4][[2;;-2]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,3}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,3}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,3}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,3}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,3}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,3}},"LCF"]

GraphData[{"SmallestFullyForested",{10,3}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,3}},"Planar"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,3}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,3}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,3}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,3}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,3}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,3}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,3}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,3}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,3}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,3}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,3}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,3}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,3}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,3}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,3}},"Halin"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,3}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,3}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,3}},"LCF"]

GraphData[{"SmallestFullyForested",{10,3}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,3}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,3}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,3}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,3}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,3}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,3}},"VertexList"],GraphData[{"SmallestFullyForested",{10,3}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,3}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,3}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,3}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,3}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,3}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,3}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,3}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,3}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,3}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 4}}

Names

GraphData[{"SmallestFullyForested",{10,4}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,4}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,4}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,4}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,4}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,4}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,4}},"VertexList"],GraphData[{"SmallestFullyForested",{10,4}},"Edges"]]]

GraphPlot@

v=Append[Drop[CirclePoints[{1,Pi/2},6],{4}],{0,0}];
v=Join[v,{Mean[v[[{1,2,6}]]]},Subdivide[{0,1/2},v[[5]],4][[2;;-2]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[Drop[CirclePoints[{1,Pi/2},6],{4}],{0,0}];
v=Join[v,{Mean[v[[{2,1,6}]]]},Subdivide[{0,1/2},v[[5]],4][[2;;-2]]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

s=Sqrt[3]/2;
v=Join[{{-1/2,0},{1/2,0},{-1,s},{0,s},{1,s}},Subdivide[{-1/4,1/6},{1/4,1/6},2]];
v=Join[v,Mean[v[[#]]]&/@{{1,3,4},{2,4,5}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,4}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,4}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,4}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,4}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,4}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,4}},"LCF"]

GraphData[{"SmallestFullyForested",{10,4}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,4}},"Planar"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,4}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,4}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,4}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,4}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,4}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,4}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,4}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,4}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,4}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,4}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,4}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,4}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,4}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,4}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,4}},"Halin"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,4}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,4}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,4}},"LCF"]

GraphData[{"SmallestFullyForested",{10,4}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,4}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,4}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,4}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,4}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,4}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,4}},"VertexList"],GraphData[{"SmallestFullyForested",{10,4}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,4}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,4}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,4}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,4}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,4}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,4}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,4}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,4}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,4}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 5}}

Names

GraphData[{"SmallestFullyForested",{10,5}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,5}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,5}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,5}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,5}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,5}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,5}},"VertexList"],GraphData[{"SmallestFullyForested",{10,5}},"Edges"]]]

GraphPlot@

v=Append[CirclePoints[6],{0,0}];
AppendTo[v,Mean[v[[{2,3,7}]]]];
v=Join[v,{{-1/6,1/2},{1/6,1/2}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v={{0,0},{3,0},{5,0},{1,1},{1,2},{3,2},{2,4},{4,4},{0,5},{5,5}}/5;
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@RotateGraph[,.15]

v=Join[CirclePoints[6],{{0,0},{-1/4,-3/5},{1/4,-3/5}}];
AppendTo[v,Mean[v[[{7,8,9}]]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,5}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,5}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,5}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,5}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,5}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,5}},"LCF"]

GraphData[{"SmallestFullyForested",{10,5}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,5}},"Planar"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,5}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,5}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,5}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,5}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,5}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,5}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,5}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,5}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,5}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,5}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,5}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,5}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,5}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,5}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,5}},"Halin"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,5}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,5}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,5}},"LCF"]

GraphData[{"SmallestFullyForested",{10,5}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,5}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,5}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,5}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,5}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,5}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,5}},"VertexList"],GraphData[{"SmallestFullyForested",{10,5}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,5}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,5}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,5}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,5}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,5}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,5}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,5}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,5}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,5}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 6}}

Names

GraphData[{"SmallestFullyForested",{10,6}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,6}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,6}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,6}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,6}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,6}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,6}},"VertexList"],GraphData[{"SmallestFullyForested",{10,6}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v=Join[{{-1/2,0},{1/2,0},{-1,s},{0,s},{1,s}},Subdivide[{-1/4,1/6},{1/4,1/6},2]];
v=Join[v,Mean[v[[#]]]&/@{{1,3,4},{2,4,5}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[CirclePoints[{1,Pi/2},7],{0,0}];
v=Join[v,Subdivide[{0,v[[7,2]]},v[[7]],3][[2;;-2]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

GraphPlot@RotateGraph[,-2.15]

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{-1/2,s},{-1/2,-s},{1/2,-s}};
v=Join[v,Subdivide[v[[6]],Mean[v[[{2,3}]]],4][[2;;-2]]];
AppendTo[v,{3/4,v[[9,2]]}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,6}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,6}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,6}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,6}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,6}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,6}},"LCF"]

GraphData[{"SmallestFullyForested",{10,6}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,6}},"Planar"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,6}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,6}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,6}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,6}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,6}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,6}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,6}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,6}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,6}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,6}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,6}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,6}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,6}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,6}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,6}},"Halin"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,6}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,6}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,6}},"LCF"]

GraphData[{"SmallestFullyForested",{10,6}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,6}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,6}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,6}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,6}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,6}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,6}},"VertexList"],GraphData[{"SmallestFullyForested",{10,6}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,6}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,6}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,6}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,6}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,6}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,6}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,6}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,6}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,6}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 7}}

Names

GraphData[{"SmallestFullyForested",{10,7}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,7}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,7}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,7}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,7}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,7}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,7}},"VertexList"],GraphData[{"SmallestFullyForested",{10,7}},"Edges"]]]

GraphPlot@RotateGraph[,3]

s=Sqrt[3]/2;
v={{0,0},{-1/2,s},{1/2,s},{1,0}};
v=Join[v,Rest@Subdivide[v[[1]],Mean[v[[{1,3,4}]]],4]];
v=Join[v,Subdivide[v[[4]],v[[8]],3][[2;;-2]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[CirclePoints[6],{0,0}];
v=Join[v,CirclePoints[Mean[v[[{4,5,7}]]],1/4,3]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphReplot@

v=Append[CirclePoints[6],{0,0}];
v=Join[v,{{-2/3,-1/4},{-1/3,-1/4},Mean[v[[{1,6,7}]]]}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[CirclePoints[{1,Pi/2},7],{0,0}];
v=Join[v,Mean[v[[#]]]&/@{{1,2,8},{1,7,8}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,,}

Degenerate

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,7}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,7}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,7}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,7}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,7}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,7}},"LCF"]

GraphData[{"SmallestFullyForested",{10,7}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,7}},"Planar"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,7}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,7}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,7}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,7}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,7}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,7}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,7}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,7}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,7}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,7}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,7}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,7}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,7}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,7}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,7}},"Halin"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,7}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,7}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,7}},"LCF"]

GraphData[{"SmallestFullyForested",{10,7}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,7}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,7}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,7}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,7}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,7}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,7}},"VertexList"],GraphData[{"SmallestFullyForested",{10,7}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,7}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,7}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,7}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,7}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,7}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,7}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,7}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,7}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,7}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 8}}

Names

GraphData[{"SmallestFullyForested",{10,8}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,8}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,8}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,8}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,8}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,8}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,8}},"VertexList"],GraphData[{"SmallestFullyForested",{10,8}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v={{-1,s},{0,s},{1,s},{-1/2,0},{1/2,0}};
v=Join[v,Mean[v[[#]]]&/@{{1,2,4},{4,5,2}},Subdivide[v[[5]],{1/2,s},4][[2;;-2]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Join[{{0,0},{1/2,0},{1,0},{1,1/2},{1,1},{0,1}},Subdivide[{1/3,3/4},{2/3,3/4},3]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,8}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,8}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,8}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,8}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,8}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,8}},"LCF"]

GraphData[{"SmallestFullyForested",{10,8}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,8}},"Planar"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,8}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,8}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,8}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,8}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,8}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,8}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,8}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,8}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,8}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,8}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,8}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,8}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,8}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,8}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,8}},"Halin"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,8}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,8}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,8}},"LCF"]

GraphData[{"SmallestFullyForested",{10,8}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,8}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,8}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,8}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,8}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,8}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,8}},"VertexList"],GraphData[{"SmallestFullyForested",{10,8}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,8}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,8}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,8}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,8}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,8}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,8}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,8}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,8}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,8}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 9}}

Names

GraphData[{"SmallestFullyForested",{10,9}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,9}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,9}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,9}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,9}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,9}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,9}},"VertexList"],GraphData[{"SmallestFullyForested",{10,9}},"Edges"]]]

GraphPlot@

s=Sqrt[3]/2;
v={{0,0},{0,1},{-s,1/2},{s,1/2}};
AppendTo[v,Mean[v[[{1,2,4}]]]];
v=Join[v,CirclePoints[Mean[v[[{1,2,3}]]],{1/3,Pi},3]];
v=Join[v,Mean[v[[#]]]&/@{{6,7},{8,7}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[CirclePoints[6],{0,0}];
AppendTo[v,Mean[v[[{1,6,7}]]]];
v=Join[v,2/3Through[{Cos,Sin}[2π#/18]]&/@{10,11}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

GraphPlot@

v=Append[CirclePoints[{1,Pi/2},7],{0,0}];
v=Join[v,Mean[v[[#]]]&/@{{1,2,8},{1,7,8}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

gs={,}

Degenerate

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,9}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,9}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,9}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,9}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,9}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,9}},"LCF"]

GraphData[{"SmallestFullyForested",{10,9}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,9}},"Planar"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,9}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,9}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,9}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,9}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,9}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,9}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,9}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,9}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,9}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,9}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,9}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,9}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,9}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,9}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,9}},"Halin"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,9}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,9}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,9}},"LCF"]

GraphData[{"SmallestFullyForested",{10,9}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,9}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,9}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,9}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,9}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,9}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,9}},"VertexList"],GraphData[{"SmallestFullyForested",{10,9}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,9}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,9}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,9}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,9}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,9}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,9}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,9}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,9}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,9}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 10}}

Names

GraphData[{"SmallestFullyForested",{10,10}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,10}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,10}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,10}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,10}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,10}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,10}},"VertexList"],GraphData[{"SmallestFullyForested",{10,10}},"Edges"]]]

GraphPlot@

v=Append[CirclePoints[6],{0,0}];
AppendTo[v,Mean[v[[{4,5,7}]]]];
v=Join[v,{{-1/6,2/3},{1/6,2/3}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,10}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,10}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,10}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,10}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,10}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,10}},"LCF"]

GraphData[{"SmallestFullyForested",{10,10}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,10}},"Planar"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,10}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,10}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,10}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,10}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,10}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,10}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,10}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,10}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,10}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,10}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,10}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,10}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,10}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,10}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,10}},"Halin"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,10}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,10}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,10}},"LCF"]

GraphData[{"SmallestFullyForested",{10,10}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,10}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,10}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,10}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,10}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,10}},"VertexList"],GraphData[{"SmallestFullyForested",{10,10}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,10}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,10}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,10}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,10}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,10}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,10}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,10}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 11}}

Names

GraphData[{"SmallestFullyForested",{10,11}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,11}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,11}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,11}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,11}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,11}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,11}},"VertexList"],GraphData[{"SmallestFullyForested",{10,11}},"Edges"]]]

GraphPlot@

v=Append[CirclePoints[{1,Pi/2},7],{0,0}];
v=Join[v,Mean[v[[#]]]&/@{{1,2,8},{1,7,8}}];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,11}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,11}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,11}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,11}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,11}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,11}},"LCF"]

GraphData[{"SmallestFullyForested",{10,11}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,11}},"Planar"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,11}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,11}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,11}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,11}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,11}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,11}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,11}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,11}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,11}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,11}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,11}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,11}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,11}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,11}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,11}},"Halin"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,11}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,11}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,11}},"LCF"]

GraphData[{"SmallestFullyForested",{10,11}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,11}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,11}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,11}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,11}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,11}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,11}},"VertexList"],GraphData[{"SmallestFullyForested",{10,11}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,11}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,11}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,11}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,11}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,11}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,11}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,11}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,11}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,11}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 12}}

Names

GraphData[{"SmallestFullyForested",{10,12}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,12}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,12}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,12}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,12}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,12}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,12}},"VertexList"],GraphData[{"SmallestFullyForested",{10,12}},"Edges"]]]

GraphPlot@

v=Append[CirclePoints[6],{0,0}];
v=Join[v,{Mean[v[[{3,4,7}]]]},Subdivide[Mean[v[[{2,7}]]],v[[3]],3][[2;;-2]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,12}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,12}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,12}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,12}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,12}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,12}},"LCF"]

GraphData[{"SmallestFullyForested",{10,12}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,12}},"Planar"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,12}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,12}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,12}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,12}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,12}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,12}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,12}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,12}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,12}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,12}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,12}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,12}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,12}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,12}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,12}},"Halin"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,12}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,12}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,12}},"LCF"]

GraphData[{"SmallestFullyForested",{10,12}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,12}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,12}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,12}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,12}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,12}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,12}},"VertexList"],GraphData[{"SmallestFullyForested",{10,12}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,12}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,12}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,12}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,12}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,12}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,12}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,12}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,12}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,12}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 13}}

Names

GraphData[{"SmallestFullyForested",{10,13}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,13}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,13}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,13}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,13}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,13}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,13}},"VertexList"],GraphData[{"SmallestFullyForested",{10,13}},"Edges"]]]

GraphPlot@RotateGraph[,-.1]

1-Sqrt[3]/4//N

v=Join[{{0,0},{1,0},{1,1},{1/2,1},{0,1},{1/4,3/4},{3/4,3/4}},Subdivide[{1/4,1/4},{3/4,1/4},2]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,13}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,13}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,13}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,13}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,13}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,13}},"LCF"]

GraphData[{"SmallestFullyForested",{10,13}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,13}},"Planar"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,13}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,13}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,13}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,13}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,13}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,13}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,13}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,13}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,13}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,13}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,13}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,13}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,13}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,13}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,13}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,13}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,13}},"Halin"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,13}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,13}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,13}},"LCF"]

GraphData[{"SmallestFullyForested",{10,13}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,13}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,13}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,13}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,13}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,13}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,13}},"VertexList"],GraphData[{"SmallestFullyForested",{10,13}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,13}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,13}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,13}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,13}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,13}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,13}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,13}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,13}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,13}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 14}}

Names

GraphData[{"SmallestFullyForested",{10,14}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,14}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,14}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,14}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,14}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,14}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,14}},"VertexList"],GraphData[{"SmallestFullyForested",{10,14}},"Edges"]]]

GraphPlot@

v={{0,0},{1,0},{1,1},{1/2,1},{0,1},{1/4,1/2},{3/4,1/2},{1/2,1/4},{1/2,1/2}};
AppendTo[v,Mean[v[[{2,7,9}]]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

Degenerate

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,14}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,14}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,14}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,14}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,14}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,14}},"LCF"]

GraphData[{"SmallestFullyForested",{10,14}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,14}},"Planar"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,14}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,14}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,14}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,14}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,14}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,14}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,14}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,14}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,14}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,14}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,14}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,14}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,14}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,14}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,14}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,14}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,14}},"Halin"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,14}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,14}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,14}},"LCF"]

GraphData[{"SmallestFullyForested",{10,14}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,14}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,14}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,14}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,14}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,14}},"VertexList"],GraphData[{"SmallestFullyForested",{10,14}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,14}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,14}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,14}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,14}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,14}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,14}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 15}}

Names

GraphData[{"SmallestFullyForested",{10,15}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,15}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,15}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,15}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,15}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,15}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,15}},"VertexList"],GraphData[{"SmallestFullyForested",{10,15}},"Edges"]]]

GraphPlot@RotateGraph[,.6]

v=Append[CirclePoints[6],{0,0}];
AppendTo[v,Mean[v[[{5,6,7}]]]];
v=Join[v,{{-1/6,-3/4},{1/6,-3/4}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,15}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,15}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,15}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,15}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,15}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,15}},"LCF"]

GraphData[{"SmallestFullyForested",{10,15}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,15}},"Planar"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,15}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,15}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,15}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,15}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,15}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,15}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,15}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,15}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,15}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,15}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,15}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,15}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,15}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,15}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,15}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,15}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,15}},"Halin"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,15}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,15}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,15}},"LCF"]

GraphData[{"SmallestFullyForested",{10,15}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,15}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,15}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,15}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,15}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,15}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,15}},"VertexList"],GraphData[{"SmallestFullyForested",{10,15}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,15}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,15}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,15}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,15}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,15}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,15}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,15}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,15}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,15}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 16}}

Names

GraphData[{"SmallestFullyForested",{10,16}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,16}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,16}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,16}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,16}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,16}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,16}},"VertexList"],GraphData[{"SmallestFullyForested",{10,16}},"Edges"]]]

GraphPlot@RotateGraph[,-.9]

v=Append[CirclePoints[6],{0,0}];
v=Join[v,Subdivide[{-1/4,-2/3},{1/4,-2/3},2]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,16}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,16}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,16}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,16}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,16}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,16}},"LCF"]

GraphData[{"SmallestFullyForested",{10,16}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,16}},"Planar"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,16}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,16}}]],10]

GraphPlot@RotateGraph[]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,16}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,16}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,16}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,16}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,16}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,16}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,16}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,16}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,16}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,16}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,16}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,16}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,16}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,16}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,16}},"Halin"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,16}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,16}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,16}},"LCF"]

GraphData[{"SmallestFullyForested",{10,16}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,16}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,16}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,16}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,16}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,16}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,16}},"VertexList"],GraphData[{"SmallestFullyForested",{10,16}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,16}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,16}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,16}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,16}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,16}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,16}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,16}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,16}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,16}},"Graph",{"3D","Polyhedron"}]

{"SmallestFullyForested", {10, 17}}

Names

GraphData[{"SmallestFullyForested",{10,17}},"StandardName"]

GraphData[{"SmallestFullyForested",{10,17}},"StandardNames"]

Primary

GraphData[{"SmallestFullyForested",{10,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestFullyForested",{10,17}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestFullyForested",{10,17}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestFullyForested",{10,17}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestFullyForested",{10,17}},"VertexList"],GraphData[{"SmallestFullyForested",{10,17}},"Edges"]]]

GraphPlot@RotateGraph[,3]

s=Sqrt[3]/2;
v={{-1,0},{0,0},{1,0},{-1/2,s},{-1/2,-s},{1/2,-s}};
AppendTo[v,Mean[v[[{2,3,6}]]]];
v=Join[v,{{-1/6,-1/2},{1/6,-1/2}}];
AppendTo[v,Mean[v[[{2,8,9}]]]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestFullyForested",{10,17}},"Graph","Degenerate"]

GeneralizedPetersen

GraphData[{"SmallestFullyForested",{10,17}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestFullyForested",{10,17}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestFullyForested",{10,17}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestFullyForested",{10,17}},"Hamiltonian"]

GraphData[{"SmallestFullyForested",{10,17}},"LCF"]

GraphData[{"SmallestFullyForested",{10,17}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestFullyForested",{10,17}},"Planar"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,17}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestFullyForested",{10,17}}]],10]

PlanarGraphEmbeddings

GraphData[{"SmallestFullyForested",{10,17}},"PlanarEmbeddingCount"]

(plemb=PlanarGraphEmbeddings[GraphData[{"SmallestFullyForested",{10,17}}],Debug->True])//Timing

Length[plemb]

MinimalCrossing

GraphData[{"SmallestFullyForested",{10,17}},{"RCN","CN"}]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"SmallestFullyForested",{10,17}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestFullyForested",{10,17}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

Circulant

GraphData[{"SmallestFullyForested",{10,17}},"Circulant"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestFullyForested",{10,17}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestFullyForested",{10,17}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestFullyForested",{10,17}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestFullyForested",{10,17}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestFullyForested",{10,17}},"Line"]

LineGraphQ[GraphData[{"SmallestFullyForested",{10,17}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestFullyForested",{10,17}}&]

RootGraph[GraphData[{"SmallestFullyForested",{10,17}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestFullyForested",{10,17}},"Halin"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestFullyForested",{10,17}},"Rigid"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestFullyForested",{10,17}},"Flexible"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestFullyForested",{10,17}},"LCF"]

GraphData[{"SmallestFullyForested",{10,17}},"HamiltonianCycleCount"]

GraphData[{"SmallestFullyForested",{10,17}},"LCFSignature"]

GraphData[{"SmallestFullyForested",{10,17}},"LCFNotations"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

UnitDistance

GraphData[{"SmallestFullyForested",{10,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestFullyForested",{10,17}}],Debug->True]//Timing

GraphData[{"SmallestFullyForested",{10,17}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestFullyForested",{10,17}},"VertexList"],GraphData[{"SmallestFullyForested",{10,17}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestFullyForested",{10,17}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,17}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestFullyForested",{10,17}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestFullyForested",{10,17}},"Matchstick"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestFullyForested",{10,17}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestFullyForested",{10,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestFullyForested",{10,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestFullyForested",{10,17}},"Polyhedral"]

GraphData[{"SmallestFullyForested",{10,17}},"Graph",{"3D","Polyhedron"}]

GraphData

GraphDataClassString

GraphDataClassString["SmallestFullyForested"]

AddIndexedClass

*minimal* (i.e., not still can't remove any edges while still containing all trees)

1-6

rules={"SingletonGraph"->{1,1},{"Path",2}->{2,1},{"Path",3}->{3,1},"PawGraph"->{4,1},"DartGraph"->{5,1},"ButterflyGraph"->{5,2},{"Matchstick",{8,4}}->{6,1},{"Matchstick",{8,1}}->{6,2}};

AddIndexedClass["SmallestFullyForested",rules,"14.3"]

RenameGraphFiles[]

7

rules={{7,240}->{7,1},{"KTree",{2,{7,4}}}->{7,2},{7,295}->{7,3},{7,403}->{7,4},{7,418}->{7,5},{"KTree",{2,{7,6}}}->{7,6},{"Fan",{1,6}}->{7,7}};

AddIndexedClass["SmallestFullyForested",rules,"14.3"]

RenameGraphFiles[]

GraphData

8-node

smallest8={,,,,,,,,,,,,};

Through[{VertexCount,EdgeCount}[#]]&/@smallest8//Union

smallest8list=MapIndexed[{#,{VertexCount[#],#2[[1]]},r=RecognizeGraph[#],DataPaclets`GraphDataDump`MyGraphQ[r]}&,smallest8]

rules=Cases[smallest8list,{_,not_,gn_,True}:>Rule[gn,not]]

AddIndexedClass["SmallestFullyForested",rules,"14.3"]

RenameGraphFiles[]

smallest8listtoadd=Cases[smallest8list,{g_,not_,_,False}:>{g,not}]

file=OpenWrite["~/fully-forested.m"]

<<MathWorld`Graphs`

WriteString[file,GraphDataString[
#,
"StandardName"->{"SmallestFullyForested",{n,k}=#2},
"Name"->"smallest fully forested "<>ToString[n]<>"\[Hyphen]graph "<>ToString[k],
"Classes"->{"SmallestFullyForested"},
"Information"->"FullyForestedGraph",
"NotationRules"->{"SmallestFullyForested"->#2},
"Skip"->{"ConstructionNumber","Minors"}
]]&@@@smallest8listtoadd;

9- and 10-node from OEIS

file=OpenWrite["~/fully-forested.m"]

WriteString[file,GraphDataString[
#,
"StandardName"->{"SmallestFullyForested",{n=VertexCount[#],1}},
"Name"->"smallest fully forested "<>ToString[n]<>"\[Hyphen]graph 1",
"Information"->"FullyForestedGraph",
"NotationRules"->{"SmallestFullyForested"->{n,1}}
]]&/@{g9,g10};

Close[file]

9-node

smallest9={,,,,,,,,,,,,,,,,,,,,,,,,};

Through[{VertexCount,EdgeCount}[#]]&/@smallest9//Union

GraphData[];

smallest9list=MapIndexed[{#,{VertexCount[#],#2[[1]]},r=RecognizeGraph[#],DataPaclets`GraphDataDump`MyGraphQ[r]}&,smallest9]

rules=Cases[smallest9list,{_,not_,gn_,True}:>Rule[gn,not]]

AddIndexedClass["SmallestFullyForested",rules,"14.3"]

RenameGraphFiles[]

smallest9listtoadd=Cases[smallest9list,{g_,not_,_,False}:>{g,not}]

file=OpenAppend["~/fully-forested.m"]

WriteString[file,GraphDataString[
#,
"StandardName"->{"SmallestFullyForested",{n,k}=#2},
"Name"->"smallest fully forested "<>ToString[n]<>"\[Hyphen]graph "<>ToString[k],
"Classes"->{"SmallestFullyForested"},
"Information"->"FullyForestedGraph",
"NotationRules"->{"SmallestFullyForested"->#2},
"Skip"->{"ConstructionNumber","ErdosSequence","GracefulLabelings","Minors","PlanarEmbedingCount","RadioLabelings","RadioNumber"}
]]&@@@Drop[smallest9listtoadd,1];

10-node

smallest10={,,,,,,,,,,,,,,,,};

Through[{VertexCount,EdgeCount}[#]]&/@smallest10//Union

smallest10list=MapIndexed[{#,{VertexCount[#],#2[[1]]},r=RecognizeGraph[#],DataPaclets`GraphDataDump`MyGraphQ[r]}&,smallest10]

rules=Cases[smallest10list,{_,not_,gn_,True}:>Rule[gn,not]]

AddIndexedClass["SmallestFullyForested",rules,"14.3"]

RenameGraphFiles[]

smallest10listtoadd=Cases[smallest10list,{g_,not_,_,False}:>{g,not}]

file=OpenWrite["~/fully-forested-10.m"]

WriteString[file,GraphDataString[
#,
"StandardName"->{"SmallestFullyForested",{n,k}=#2},
"Name"->"smallest fully forested "<>ToString[n]<>"\[Hyphen]graph "<>ToString[k],
"Classes"->{"SmallestFullyForested"},
"Information"->"FullyForestedGraph",
"NotationRules"->{"SmallestFullyForested"->#2},
"Skip"->{"ConstructionNumber","CyclicEdgeCuts","EdgeCuts","ErdosSequence","GracefulLabelings","Monirs","PinnacleSets","PlanarEmbedingCount","RadioLabelings","RadioNumber"}
]]&@@@smallest10listtoadd;