Smallest Quartic Crossing Number Graph

Author

Eric W. Weisstein
September 24, 2025

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

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

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

Reference

https://www.mathematica-journal.com/data/uploads/2009/11/CrossingNumberGraphs.pdf

Embeddings

<<MathWorld`Graphs`

TextGrid[Sort[DeleteCases[
{FirstCase[GraphData[#,"StandardNames"],{"SmallestQuarticCrossing",_}],#}&/@GraphData["Quartic"],
{_Missing,_}]],Dividers->All]

{"SmallestQuarticCrossing", {0, 1}} == "OctahedralGraph"

Names

GraphData[{"SmallestQuarticCrossing",{0,1}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{0,1}},"StandardNames"]

{"SmallestQuarticCrossing", {1, 1}} == "PentatopeGraph"

Names

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

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

{"SmallestQuarticCrossing", {2, 1}} == "CoC4+C3"

Names

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

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

{"SmallestQuarticCrossing", {3, 1}}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Quartic",{9,13}},"EdgeList"]]

Default embedding

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

RotateGraph[GraphicsToGraph@,Pi]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Quartic",{9,13}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"Quartic",{9,13}},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

GraphData[{"Quartic",{9,13}},"Planar"]

GraphData[{"Quartic",{9,13}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

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

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Quartic",{9,13}}],TimeConstraint->10])//AbsoluteTiming

CrossingNumber[GraphData[{"Quartic",{9,13}}],TimeConstraint->60]//AbsoluteTiming

g=RotateGraph[MinimalCrossingGraph[GraphData[{"Quartic",{9,13}}],"CrossingNumber"->cn]]

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Quartic",{9,13}}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Quartic",{9,13}},"V"]&]]//Timing

RegionIntersection[Line[v[[{4,7}]]],Line[v[[{1,6}]]]]//FullSimplify

v=Join[UnitCirclePoints[4,-Pi/2],CirclePoints[{1/4,Pi/2},4],-(1/14) (-4+(Sqrt[2])){#,1}&/@{-1,1}];
g=VertexDelete[Graph[Range[Length[v]],UndirectedEdge@@@{e[6,1,2,3,4,1,8],e[4,7,2,10,3,9,4],e[6,7,8,9,6],e[6,10,8]},VertexCoordinates->v,VertexLabels->Automatic],5]

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Quartic",{9,13}},"Circulant"]

GraphData[{"Quartic",{9,13}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Quartic",{9,13}},"Halin"]

GraphData[{"Quartic",{9,13}},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"Quartic",{9,13}},"LCF"]

GraphData[{"Quartic",{9,13}},"LCFSignature"]

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

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

LCF compute

Length[FindHamiltonianCycle[GraphData[{"Quartic",{9,13}}],All][[All,All,1]]]//Timing

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

gs=LCFGraph@@@lcf//StyleGraphs

gs=Join[With[{g=BilateralLCFEmbedding[#]},If[MissingQ[g],#,g]]&/@LCFGraph@@@DeleteCases[lcf,{_,1}],DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,1}]]]

UnitDistance

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

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

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

Matchstick

GraphData[{"Quartic",{9,13}},"Matchstick"]

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Quartic",{9,13}},"Polyhedral"]

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

{"SmallestQuarticCrossing", {3, 2}} == {"Circulant", {9, {1, 3}}}

Names

GraphData[{"SmallestQuarticCrossing",{3,2}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{3,2}},"StandardNames"]

{"SmallestQuarticCrossing", {3, 3}}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Quartic",{9,15}},"EdgeList"]]

Default embedding

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

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

RecognizeGraph[g]

Degenerate

GraphData[{"Quartic",{9,15}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"Quartic",{9,15}},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

GraphData[{"Quartic",{9,15}},"Planar"]

GraphData[{"Quartic",{9,15}},"Graph","Planar"]//StyleGraphs

MinimalLocalCrossing

GraphData[{"Quartic",{9,15}},"LocalCrossingNumber"]

GraphData[{"Quartic",{9,15}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

GraphPlot@RotateGraph[,Pi/4]

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

RecognizeGraph[g]

LocalCrossingCount@g

MinimalCrossing

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

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Quartic",{9,15}}],TimeConstraint->10])//AbsoluteTiming

CrossingNumber[GraphData[{"Quartic",{9,15}}],TimeConstraint->60]//AbsoluteTiming

g=RotateGraph[MinimalCrossingGraph[GraphData[{"Quartic",{9,15}}],"CrossingNumber"->cn]]

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Quartic",{9,15}}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Quartic",{9,15}},"V"]&]]//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Quartic",{9,15}},"Circulant"]

GraphData[{"Quartic",{9,15}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Quartic",{9,15}},"Halin"]

GraphData[{"Quartic",{9,15}},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"Quartic",{9,15}},"LCF"]

GraphData[{"Quartic",{9,15}},"LCFSignature"]

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

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

LCF compute

Length[FindHamiltonianCycle[GraphData[{"Quartic",{9,15}}],All][[All,All,1]]]//Timing

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

gs=LCFGraph@@@lcf//StyleGraphs

gs=Join[With[{g=BilateralLCFEmbedding[#]},If[MissingQ[g],#,g]]&/@LCFGraph@@@DeleteCases[lcf,{_,1}],DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,1}]]]

UnitDistance

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

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

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

Matchstick

GraphData[{"Quartic",{9,15}},"Matchstick"]

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Quartic",{9,15}},"Polyhedral"]

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

{"SmallestQuarticCrossing", {3, 4}}

Names

GraphData[{"SmallestQuarticCrossing",{3,4}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{3,4}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Quartic",{9,2}},"EdgeList"]]

Default embedding

GraphPlot[GraphData[{"Quartic",{9,2}},"Edges"],GraphLayout->"SpringEmbedding"]

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

RecognizeGraph[g]

Degenerate

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

Bilateral

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

Circular

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

Planar

GraphData[{"Quartic",{9,2}},"Planar"]

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

MinimalCrossing

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

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Quartic",{9,2}}],TimeConstraint->10])//AbsoluteTiming

CrossingNumber[GraphData[{"Quartic",{9,2}}],TimeConstraint->60]//AbsoluteTiming

g=RotateGraph[MinimalCrossingGraph[GraphData[{"Quartic",{9,2}}],"CrossingNumber"->cn]]

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"Quartic",{9,2}}],"CrossingNumber"->cn,RandomSeed->n]],{n,50}],Max[OuterFace[#]]<=GraphData[{"Quartic",{9,2}},"V"]&]]//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Quartic",{9,2}},"Circulant"]

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

Halin

GraphData[{"Quartic",{9,2}},"Halin"]

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

LCF

GraphData[{"Quartic",{9,2}},"LCF"]

GraphData[{"Quartic",{9,2}},"LCFSignature"]

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

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

LCF compute

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

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

gs=LCFGraph@@@lcf//StyleGraphs

gs=Join[With[{g=BilateralLCFEmbedding[#]},If[MissingQ[g],#,g]]&/@LCFGraph@@@DeleteCases[lcf,{_,1}],DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,1}]]]

UnitDistance

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

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

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

Matchstick

GraphData[{"Quartic",{9,2}},"Matchstick"]

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Quartic",{9,2}},"Polyhedral"]

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

{"SmallestQuarticCrossing", {3, 5}} == {"GeneralizedQuadrangle", {2, 1}}

Names

GraphData[{"SmallestQuarticCrossing",{3,5}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{3,5}},"StandardNames"]

{"SmallestQuarticCrossing", {4, 1}} == {"CompleteBipartite", {4, 4}}

Names

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

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

{"SmallestQuarticCrossing", {5, 1}} == {"Circulant", {10, {1, 4}}}

Names

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

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

{"SmallestQuarticCrossing", {6, 1}} == {"Circulant", {12, {1, 5}}}

Names

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

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

{"SmallestQuarticCrossing", {6, 2}} == {"QuarticTransitive", 23}

Names

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

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

{"SmallestQuarticCrossing", {6, 3}}

Names

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"StandardNames"]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,3}} ]]

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Planar"]

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6, 3 succeeded
Date: 	Sun, 21 Sep 2025 12:39:08 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6, 3).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/XUHxYcX052LWuwjMnG_IiQ

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"RCN"]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,3}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,3}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,3}} ],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,3}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,3}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

v={{0,0},{5,0},{5,5},{0,5},{2,1},{3,1},{1,2},{4,2},{2,2},{3,2},{2,4},{3,4},{2,3},{3,3}}/5;
g=EdgeAdd[IndexGraph@VertexDelete[Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,1,6,5,2,8,10,9,7,1],e[7,11,12,8,6,10,14,12,4,13,14,3,11,13,9,5,7]},VertexCoordinates->v,VertexLabels->Automatic],{9,10}],UndirectedEdge@@@{{5,11},{6,12},{7,8}}]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,3}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,3}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,3}} ],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,3}} ]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,3}} ]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,3}} ,"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,3}} ,"Polyhedral"]

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

{"SmallestQuarticCrossing", {6, 4}}

Names

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"StandardNames"]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,4}} ]]

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Planar"]

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6, 4 succeeded
Date: 	Sun, 21 Sep 2025 12:39:45 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de


EXTERNAL EMAIL: Be careful when responding or clicking links!   [Wolfram SysOps]

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6, 4).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/D0Oyb61-1K4F-LVWuVfweg

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"RCN"]

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

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,4}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,4}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,4}} ],"CrossingNumber"->cn,RandomSeed->n],{n,10000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,4}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,4}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@RotateGraph[,Pi/2]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,4}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,4}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,4}} ],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,4}} ]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,4}} ]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,4}} ,"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"UnitDistance"]

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

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

UnitDistance by refinement

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,4}} ,"Polyhedral"]

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

{"SmallestQuarticCrossing", {6, 5}}

Names

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"StandardNames"]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,5}} ]]

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Planar"]

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6, 5 succeeded
Date: 	Sun, 21 Sep 2025 12:48:45 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6, 5).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/GcQo0GFBYS8s8Kw6b0MC6A

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"RCN"]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,5}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,5}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,5}} ],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,5}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,5}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@RotateGraph[,Pi]

GraphReplot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

GraphPlot@RotateGraph[,Pi]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

GraphPlot@

GraphReplot@

Rotate[,Pi]

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

VertexDegree[g]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

gs=UnlabelGraph/@{,,}

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,5}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,5}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,5}} ],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,5}} ]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,5}} ]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,5}} ,"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,5}} ,"Polyhedral"]

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

{"SmallestQuarticCrossing", {6, 6}}

Names

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

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

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

RotateGraph[GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{6,6}} ,"VertexList"],GraphData[{"SmallestQuarticCrossing",{6,6}} ,"Edges"]],GraphLayout->"HighDimensionalEmbedding"],Pi/2]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes[g]

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6, 6 succeeded
Date: 	Sun, 21 Sep 2025 13:13:15 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6, 6).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/QYcS8WVckU9smuvhi35v4g

MinimalCrossing

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

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

MinimalRectilinearCrossing

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

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

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalCrossing construction

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

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,6}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,6}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,6}} ],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,6}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,6}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

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

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

MinimalRectilinearLocalCrossing

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

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

MinimaRectilinearlLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

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

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"SmallestQuarticCrossing", {6, 7}}

Names

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

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

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,7}} ]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{6,7}} ,"VertexList"],GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Edges"]],GraphLayout->"HighDimensionalEmbedding"]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"HamiltonianCycleCount"]

Planar

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6,7 succeeded
Date: 	Mon, 22 Sep 2025 00:18:56 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6,7).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/8aRJmR7eZqXW781IRiEbVw

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"RCN"]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,7}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,7}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,7}} ],"CrossingNumber"->cn,RandomSeed->n],{n,20000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,7}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,7}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,7}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,7}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,7}} ],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,7}} ]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,7}} ]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"HamiltonianCycleCount"]

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

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,7}} ,"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,7}} ,"Polyhedral"]

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

{"SmallestQuarticCrossing", {6, 8}}

Names

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

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

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

RotateGraph[,Pi/2]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

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

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,8}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,8}}],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6,8 succeeded
Date: 	Mon, 22 Sep 2025 01:11:16 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6,8).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/MG5etaO4vaJXXnCYMRxOFw

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,8}},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,8}},"RCN"]

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

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalCrossing construction

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

Tutte:

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,8}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,8}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,8}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,8}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,8}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@RotateGraph[,Pi]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

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

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

MinimalRectilinearLocalCrossing

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

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

MinimaRectilinearlLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,8}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"SmallestQuarticCrossing", {6, 9}}

Names

GraphData[{"SmallestQuarticCrossing",{6,9}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,9}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,9}}]]

Default embedding

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

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,9}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,9}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,9}},"HamiltonianCycleCount"]

Planar

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,9}}],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6,9 succeeded
Date: 	Mon, 22 Sep 2025 12:14:15 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6,9).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/r47nQNcJ5IizKv8GFkKmcg

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,9}},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,9}},"RCN"]

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

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,9}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,9}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,9}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,9}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,9}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,9}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

GraphPlot@RotateGraph[,Pi]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

gs=UnlabelGraph/@{,,}

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,9}}],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,9}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,9}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,9}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,9}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,9}}]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,9}},"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,9}},"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,9}},"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,9}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,9}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{6,9}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{6,9}},"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,9}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,9}},"Matchstick"]

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,9}},"Polyhedral"]

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

{"SmallestQuarticCrossing", {6, 10}}

Names

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"StandardName"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"StandardNames"]

Primary

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Degenerate"]

Bilateral

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Planar"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},{"RCN","CN"}]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"V"]&]]//Timing

Table[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],"CrossingNumber"->cn,RandomSeed->i],{i,500}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],"CrossingNumber"->cn,RandomSeed->n]],{n,150}],Max[OuterFace[#]]<=GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"V"]&]]//Timing

GraphPlot@

Table[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

MinimalLocalCrossing

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"LocalCrossingNumber"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],TimeConstraint->1])//AbsoluteTiming

Select[Table[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],"CrossingNumber"->cn,RandomSeed->i],{i,500}],!AdjacentCrossingsQ[#,cn]&]//Union//Timing

GraphPlot@RotateGraph[,-4Pi/5]

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

RecognizeGraph@g

RectilinearCrossingCount@g

LocalCrossingCount@g

Circulant

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Circulant"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Halin"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Rigid"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Flexible"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"LCF"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"HamiltonianCycleCount"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"LCFSignature"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"LCFNotations"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],All][[All,All,1]]]//Timing

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

lcf

LCFGraph@@@lcf//StyleGraphs

(gs=Flatten[{
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFGraph@@@Cases[lcf,{_,1}]]}])//Timing

Length[gs]

UnitDistance

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],Debug->True]//Timing

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"VertexList"],GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"EdgeList"]]]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]]]&/@Complement@@(GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Matchstick"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Edges"]]

3D All

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Polyhedral"]

GraphData[{"RegularNonplanarDiameter",{4,2,12,22}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {6, 11}} == "ChvatalGraph"

Names

GraphData[{"SmallestQuarticCrossing",{6,11}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,11}},"StandardNames"]

{"SmallestQuarticCrossing", {6, 12}}

Names

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"StandardNames"]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,12}} ]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{6,12}} ,"VertexList"],GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Edges"]],GraphLayout->"HighDimensionalEmbedding"]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Planar"]

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC ,12 succeeded
Date: 	Mon, 22 Sep 2025 12:22:22 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC ,12).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/_Mly4zvqziiRSx_EJi8Qlw

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"RCN"]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,12}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,12}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,12}} ],"CrossingNumber"->cn,RandomSeed->n],{n,10000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,12}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,12}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,12}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,12}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,12}} ],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,12}} ]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,12}} ]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,12}} ,"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,12}} ,"Polyhedral"]

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

{"SmallestQuarticCrossing", {6, 13}}

Names

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"StandardNames"]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,13}} ]]

Default embedding

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"V"]

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{6,13}} ,"VertexList"],GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Edges"]],GraphLayout->"HighDimensionalEmbedding"]

GraphReplot@

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

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

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Planar"]

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6,13 succeeded
Date: 	Mon, 22 Sep 2025 13:00:35 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6,13).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/FmStY9aZfZgZei6uYYtpAw

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"RCN"]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,13}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,13}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,13}} ],"CrossingNumber"->cn,RandomSeed->n],{n,10000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,13}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,13}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,13}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,13}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,13}} ],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,13}} ]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,13}} ]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,13}} ,"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,13}} ,"Polyhedral"]

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

{"SmallestQuarticCrossing", {6, 14}}

Names

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"StandardName"]

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"StandardNames"]

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{6,14}} ]]

Default embedding

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

RotateGraph[,-Pi/2]

v=Join[CirclePoints[6],Sequence@@Table[{i/4,j/4},{i,{-1,1}},{j,-1,1}]];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Planar"]

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 6]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 6,14 succeeded
Date: 	Mon, 22 Sep 2025 13:09:12 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 6,14).
The graph has a crossing number of 6.

Please visit this link for detailed results: https://crossings.uos.de/job/6-QTga12ftcicAaphPwvZw

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"RCN"]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,14}} ,"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,14}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{6,14}} ],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{6,14}} ,"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{6,14}} ,"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

gs=UnlabelGraph/@{,}

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,14}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{6,14}} ,{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{6,14}} ],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{6,14}} ]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{6,14}} ]]

Halin

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"LCF"]

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{6,14}} ,"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{6,14}} ,"Polyhedral"]

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

{"SmallestQuarticCrossing", {7, 1}}

Names

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

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

Primary

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

All

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

Inexact

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

Embeddings

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

Default embedding

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

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

g=FindCorrespondingGraph[,v]//Quiet

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

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

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

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

Planar

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,1}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 7]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,1}}],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 7,1 succeeded
Date: 	Mon, 22 Sep 2025 17:15:54 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 7,1).
The graph has a crossing number of 7.

Please visit this link for detailed results: https://crossings.uos.de/job/UWV-NcRlMKaNRMoqs_6mzw

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,1}},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,1}},"RCN"]

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

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalCrossing construction

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

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,1}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,1}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,1}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,1}}],"CrossingNumber"->cn,RandomSeed->n],{n,20000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,1}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,1}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@RotateGraph[,-34Pi/5]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

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

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

MinimalRectilinearLocalCrossing

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

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

MinimaRectilinearlLocalCrossing construction

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

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

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

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

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

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

Circulant

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

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

Circulant construction

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

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,1}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"SmallestQuarticCrossing", {7, 2}}

Names

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

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

Primary

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

All

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

Inexact

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

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,2}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,2}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,2}},"Edges"]],GraphLayout->"HighDimensionalEmbedding"]

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

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

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

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

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

GeneralizedPetersen

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

IGraph

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

Bilateral

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

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

Circular

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

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,2}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,2}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,2}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,2}},"Planar"]

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

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,2}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,2}},"CN"]

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

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,2}},"RCN"]

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

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

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

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

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

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,2}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,2}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,2}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,2}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,2}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,2}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@RotateGraph[,Pi]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,2}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction

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

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,2}}],TimeConstraint->10])//AbsoluteTiming

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

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

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

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

Circulant

GraphData[{"SmallestQuarticCrossing",{7,2}},"Circulant"]

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

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,2}},"NotationRules","Circulant"]

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

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Complement graph

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

Line graph

GraphData[{"SmallestQuarticCrossing",{7,2}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,2}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,2}}]]

Halin

GraphData[{"SmallestQuarticCrossing",{7,2}},"Halin"]

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

Rigid

GraphData[{"SmallestQuarticCrossing",{7,2}},"Rigid"]

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

Flexible

GraphData[{"SmallestQuarticCrossing",{7,2}},"Flexible"]

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

LCF

GraphData[{"SmallestQuarticCrossing",{7,2}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,2}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,2}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,2}},"LCFNotations"]

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

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

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,2}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,2}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,2}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,2}},"Edges"]]

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,2}},"Polyhedral"]

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

{"SmallestQuarticCrossing", {7, 3}}

Names

GraphData[{"SmallestQuarticCrossing",{7,3}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,3}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,3}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,3}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,3}},"Edges"]],GraphLayout->"HighDimensionalEmbedding"]

v=Join[UnitCirclePoints[10],{{-1/2,0},{0,0},{1/2,0}}];
Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]//Quiet

RecognizeGraph@g

DegenerateGraphEmbeddingTypes@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,3}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,3}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,3}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,3}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,3}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,3}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,3}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,3}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,3}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,3}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,3}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,3}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@RotateGraph[,Pi]

v={{-1,0},{1,0},{0,Sqrt[3]},{-1/2,1/4},{-1/6,1/4},{1/6,1/4},{1/2,1/4},{-1/6,1/2},{-1/18,1/2},{1/18,1/2},{1/6,1/2},{-1/6,3/4},{1/6,3/4}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,13,3,12,1,6,7,3,4,1],e[4,5,2,7,10,5,8,12,11,13,8,9,10,11,6,9,4]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,3}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,3}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,3}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,3}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,3}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,3}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,3}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,3}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,3}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,3}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,3}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,3}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,3}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,3}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,3}}]]

Halin

GraphData[{"SmallestQuarticCrossing",{7,3}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,3}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,3}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,3}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,3}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,3}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,3}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,3}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,3}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,3}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,3}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,3}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,3}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,3}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,3}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,3}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,3}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 4}}

Names

GraphData[{"SmallestQuarticCrossing",{7,4}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,4}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,4}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,4}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,4}},"Edges"]],GraphLayout->"HighDimensionalEmbedding"]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,4}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,4}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,4}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,4}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,4}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,4}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,4}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,4}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,4}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,4}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,4}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,4}}],"CrossingNumber"->cn,RandomSeed->n],{n,20000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,4}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,4}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

v={#/6,#2/5}&@@@{{0,0},{6,0},{1,1},{4,1},{1,2},{2,2},{3,2},{5,2},{4,3},{4,4},{0,5},{2,5},{6,5}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,13,12,11,1,5,3,11,9,7,3,2,8,7,6,5,10,13,8,4,9,10,12,6,4,1]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,4}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,4}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,4}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,4}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,4}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,4}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,4}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,4}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,4}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,4}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,4}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,4}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,4}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,4}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,4}}]]

Halin

GraphData[{"SmallestQuarticCrossing",{7,4}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,4}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,4}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,4}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,4}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,4}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,4}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,4}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,4}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,4}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,4}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,4}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,4}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,4}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,4}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,4}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,4}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 5}}

Names

GraphData[{"SmallestQuarticCrossing",{7,5}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,5}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,5}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,5}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,5}},"Edges"]],GraphLayout->"RadialEmbedding"]

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,5}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,5}},"Edges"]],GraphLayout->"HighDimensionalEmbedding"]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,5}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,5}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,5}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,5}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,5}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,5}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,5}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,5}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,5}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,5}}],"CrossingNumber"->cn,RandomSeed->n],{n,10000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,5}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,5}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

v={#/5,#2/4}&@@@{{0,0},{5,0},{1,1},{4,1},{1,2},{2,2},{3,2},{4+1/2,2},{1,3},{4,3},{0,4},{5/2,4},{5,4}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,13,12,11,1,4,10,11,3,5,9,12,10,7,3,2,8,7,6,5,1],e[9,6,4],{9,13},e[4,8,13]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,5}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,5}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,5}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,5}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,5}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,5}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,5}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,5}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,5}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,5}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,5}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,5}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,5}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,5}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,5}}]]

Halin

GraphData[{"SmallestQuarticCrossing",{7,5}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,5}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,5}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,5}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,5}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,5}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,5}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,5}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,5}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,5}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,5}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,5}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,5}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,5}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,5}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,5}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,5}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,5}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,5}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 6}}

Names

GraphData[{"SmallestQuarticCrossing",{7,6}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,6}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,6}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,6}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,6}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,6}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,6}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,6}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,6}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,6}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,6}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,6}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,6}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,6}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,6}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,6}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,6}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,6}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,6}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,6}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,6}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,6}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,6}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,6}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,6}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,6}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,6}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,6}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,6}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,6}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,6}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,6}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,6}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,6}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,6}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,6}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,6}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,6}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,6}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,6}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,6}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,6}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,6}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,6}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,6}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,6}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,6}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,6}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,6}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,6}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,6}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,6}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,6}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 7}}

Names

GraphData[{"SmallestQuarticCrossing",{7,7}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,7}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,7}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,7}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,7}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,7}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,7}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,7}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,7}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,7}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,7}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,7}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,7}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,7}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,7}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,7}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,7}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,7}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,7}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,7}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,7}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,7}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,7}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,7}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,7}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,7}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,7}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,7}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,7}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,7}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,7}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,7}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,7}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,7}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,7}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,7}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,7}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,7}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,7}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,7}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,7}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,7}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,7}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,7}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,7}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,7}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,7}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,7}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,7}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,7}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,7}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,7}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 8}}

Names

GraphData[{"SmallestQuarticCrossing",{7,8}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,8}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,8}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,8}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,8}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,8}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,8}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"HamiltonianCycleCount"]

Circular construction old

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilateralGraph/@circ],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

GraphData[{"SmallestQuarticCrossing",{7,8}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Planar"]//StyleGraphs

Planar construction

PlanarGraphEmbedding[GraphData[{"SmallestQuarticCrossing",{7,8}}],GraphLayout->#]&/@{"TutteLayout","DavidsonHarelLayout"}

Table[PlanarGraphEmbedding[GraphData[{"SmallestQuarticCrossing",{7,8}}]],10]

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,8}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,8}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,8}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,8}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,8}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,8}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,8}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,8}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,8}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,8}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,8}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,8}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,8}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,8}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,8}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,8}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,8}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,8}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,8}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,8}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,8}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,8}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,8}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,8}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,8}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,8}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,8}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,8}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,8}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,8}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,8}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,8}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,8}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,8}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,8}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,8}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,8}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,8}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,8}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,8}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,8}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,8}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,8}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,8}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 9}}

Names

GraphData[{"SmallestQuarticCrossing",{7,9}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,9}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,9}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,9}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,9}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,9}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,9}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,9}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,9}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,9}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,9}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,9}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,9}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,9}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,9}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,9}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,9}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,9}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,9}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,9}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,9}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,9}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,9}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,9}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,9}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,9}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,9}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,9}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,9}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,9}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,9}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,9}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,9}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,9}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,9}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,9}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,9}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,9}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,9}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,9}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,9}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,9}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,9}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,9}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,9}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,9}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,9}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,9}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,9}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,9}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,9}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,9}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,9}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 10}}

Names

GraphData[{"SmallestQuarticCrossing",{7,10}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,10}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,10}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,10}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,10}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,10}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,10}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,10}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,10}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,10}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,10}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,10}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,10}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,10}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,10}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,10}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,10}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,10}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,10}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,10}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,10}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,10}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,10}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,10}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,10}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,10}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,10}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,10}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,10}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,10}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,10}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,10}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,10}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,10}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,10}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,10}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,10}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,10}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,10}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,10}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,10}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,10}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,10}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,10}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,10}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,10}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,10}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,10}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,10}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,10}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,10}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 11}}

Names

GraphData[{"SmallestQuarticCrossing",{7,11}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,11}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,11}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,11}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,11}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,11}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,11}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,11}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,11}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,11}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,11}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,11}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,11}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,11}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,11}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,11}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,11}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,11}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,11}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,11}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,11}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,11}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,11}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,11}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,11}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,11}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,11}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,11}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,11}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,11}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,11}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,11}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,11}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,11}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,11}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,11}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,11}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,11}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,11}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,11}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,11}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,11}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,11}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,11}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,11}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,11}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,11}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,11}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,11}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,11}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,11}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,11}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,11}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 12}}

Names

GraphData[{"SmallestQuarticCrossing",{7,12}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,12}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,12}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,12}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,12}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,12}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,12}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,12}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,12}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,12}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,12}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,12}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,12}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,12}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,12}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,12}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,12}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,12}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,12}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,12}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,12}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,12}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,12}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,12}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,12}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,12}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,12}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,12}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,12}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,12}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,12}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,12}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,12}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,12}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,12}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,12}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,12}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,12}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,12}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,12}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,12}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,12}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,12}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,12}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,12}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,12}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,12}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,12}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,12}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,12}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,12}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,12}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 13}}

Names

GraphData[{"SmallestQuarticCrossing",{7,13}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,13}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,13}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,13}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,13}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,13}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,13}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,13}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,13}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,13}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,13}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,13}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,13}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,13}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,13}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,13}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,13}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,13}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,13}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,13}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,13}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,13}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,13}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,13}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,13}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,13}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,13}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,13}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,13}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,13}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,13}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,13}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,13}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,13}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,13}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,13}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,13}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,13}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,13}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,13}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,13}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,13}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,13}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,13}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,13}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,13}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,13}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,13}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,13}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,13}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,13}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,13}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,13}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,13}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 14}}

Names

GraphData[{"SmallestQuarticCrossing",{7,14}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,14}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,14}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,14}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,14}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,14}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,14}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,14}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,14}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,14}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,14}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,14}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,14}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,14}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,14}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,14}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,14}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,14}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,14}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,14}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,14}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,14}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,14}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,14}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,14}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,14}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,14}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,14}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,14}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,14}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,14}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,14}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,14}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,14}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,14}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,14}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,14}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,14}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,14}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,14}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,14}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,14}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,14}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,14}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,14}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,14}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,14}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,14}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,14}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,14}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,14}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,14}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 15}}

Names

GraphData[{"SmallestQuarticCrossing",{7,15}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,15}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,15}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,15}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,15}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,15}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,15}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,15}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,15}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,15}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,15}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,15}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,15}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,15}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,15}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,15}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,15}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,15}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,15}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,15}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,15}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,15}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,15}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,15}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,15}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,15}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,15}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,15}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,15}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,15}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,15}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,15}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,15}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,15}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,15}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,15}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,15}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,15}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,15}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,15}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,15}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,15}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,15}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,15}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,15}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,15}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,15}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,15}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,15}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,15}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,15}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,15}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,15}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,15}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 16}}

Names

GraphData[{"SmallestQuarticCrossing",{7,16}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,16}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,16}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,16}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,16}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,16}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,16}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,16}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,16}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,16}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,16}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,16}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,16}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,16}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,16}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,16}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,16}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,16}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,16}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,16}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,16}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,16}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,16}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,16}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,16}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,16}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,16}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,16}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,16}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,16}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,16}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,16}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,16}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,16}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,16}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,16}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,16}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,16}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,16}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,16}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,16}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,16}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,16}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,16}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,16}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,16}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,16}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,16}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,16}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,16}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,16}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,16}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,16}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,16}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 17}}

Names

GraphData[{"SmallestQuarticCrossing",{7,17}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,17}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,17}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,17}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,17}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,17}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,17}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,17}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,17}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,17}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,17}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,17}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,17}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,17}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,17}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,17}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,17}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,17}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,17}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,17}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,17}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,17}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,17}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,17}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,17}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,17}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,17}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,17}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,17}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,17}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,17}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,17}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,17}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,17}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,17}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,17}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,17}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,17}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,17}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,17}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,17}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,17}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,17}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,17}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,17}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,17}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,17}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,17}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,17}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,17}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,17}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,17}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 18}}

Names

GraphData[{"SmallestQuarticCrossing",{7,18}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,18}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,18}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,18}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,18}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,18}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,18}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,18}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,18}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,18}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,18}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,18}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,18}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,18}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,18}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,18}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,18}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,18}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,18}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,18}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,18}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,18}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,18}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,18}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,18}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,18}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,18}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,18}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,18}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,18}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,18}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,18}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,18}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,18}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,18}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,18}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,18}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,18}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,18}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,18}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,18}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,18}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,18}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,18}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,18}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,18}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,18}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,18}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,18}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,18}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,18}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,18}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,18}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,18}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 19}}

Names

GraphData[{"SmallestQuarticCrossing",{7,19}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,19}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,19}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,19}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,19}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,19}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,19}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,19}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,19}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,19}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,19}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,19}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,19}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,19}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,19}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,19}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,19}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,19}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,19}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,19}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,19}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,19}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,19}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,19}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,19}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,19}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,19}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,19}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,19}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,19}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,19}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,19}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,19}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,19}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,19}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,19}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,19}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,19}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,19}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,19}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,19}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,19}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,19}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,19}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,19}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,19}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,19}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,19}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,19}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,19}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,19}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,19}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,19}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,19}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing",{7,20}}

Names

GraphData[{"SmallestQuarticCrossing",{7,20}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,20}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,20}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,20}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,20}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,20}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,20}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,20}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,20}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,20}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,20}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,20}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,20}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,20}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,20}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,20}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,20}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,20}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,20}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,20}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,20}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,20}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,20}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,20}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,20}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,20}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,20}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,20}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,20}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,20}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,20}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,20}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,20}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,20}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,20}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,20}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,20}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,20}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,20}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,20}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,20}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,20}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,20}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,20}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,20}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,20}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,20}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,20}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,20}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,20}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,20}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,20}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,20}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,20}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing",{7,21}}

Names

GraphData[{"SmallestQuarticCrossing",{7,21}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,21}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,21}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,21}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,21}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,21}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,21}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,21}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,21}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,21}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,21}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,21}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,21}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,21}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,21}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,21}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,21}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,21}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,21}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,21}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,21}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,21}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,21}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,21}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,21}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,21}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,21}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,21}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,21}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,21}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,21}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,21}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,21}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,21}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,21}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,21}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,21}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,21}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,21}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,21}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,21}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,21}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,21}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,21}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,21}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,21}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,21}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,21}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,21}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,21}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,21}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,21}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,21}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,21}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing",{7,22}}

Names

GraphData[{"SmallestQuarticCrossing",{7,22}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,22}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,22}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,22}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,22}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,22}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,22}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,22}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,22}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,22}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,22}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,22}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,22}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,22}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,22}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,22}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,22}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,22}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,22}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,22}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,22}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,22}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,22}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,22}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,22}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,22}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,22}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,22}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,22}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,22}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,22}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,22}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,22}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,22}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,22}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,22}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,22}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,22}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,22}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,22}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,22}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,22}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,22}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,22}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,22}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,22}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,22}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,22}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,22}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,22}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,22}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,22}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,22}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,22}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 23}}

Names

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"StandardName"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"StandardNames"]

Primary

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}]]

Default embedding

GraphPlot[Graph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"VertexList"],GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Hamiltonian"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"LCF"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"HamiltonianCycleCount"]

Planar

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Planar"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 7]

https://crossings.uos.de/job/new

ExportString[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] RNPD 4, 2, 13, 8 succeeded
Date: 	Fri, 19 Sep 2025 23:52:55 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de


Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (RNPD 4, 2, 13, 8).
The graph has a crossing number of 7.

Please visit this link for detailed results: https://crossings.uos.de/job/4FDe8vUP0IgMqbxHKeXcog

MinimalCrossing

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"CN"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"RCN"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"CrossingNumber"->cn,RandomSeed->n],{n,10000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphPlot@

v={{0,0},{1,0},{1,1},{0,1},{1/4,1/5},{1/2,1/5},{3/4,1/5},{1/4,2/5},{1/2,2/5},{3/4,2/5},{1/4,3/5},{1/4,4/5},{1/2,1}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,13,4,1,7,6,5,2,10,7],e[1,8,9,10],e[8,5,4,12,10],e[3,11,12,13,9,6],e[8,11,6],{3,7}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Circulant"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"ComplementGraph","Name"]

Line graph

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Line"]

LineGraphQ[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"RegularNonplanarDiameter",{4,2,13,8}}&]

RootGraph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}]]

Halin

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Halin"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Rigid"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Flexible"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"LCF"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"HamiltonianCycleCount"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"LCFSignature"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"LCFNotations"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],Debug->True]//Timing

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"VertexList"],GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"RegularNonplanarDiameter",{4,2,13,8}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Matchstick"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Polyhedral"]

GraphData[{"RegularNonplanarDiameter",{4,2,13,8}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 24}}

Names

GraphData[{"SmallestQuarticCrossing",{7,24}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,24}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,24}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,24}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,24}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,24}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,24}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,24}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,24}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,24}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,24}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,24}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,24}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,24}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,24}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,24}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,24}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,24}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,24}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,24}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,24}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,24}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,24}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,24}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,24}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,24}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,24}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,24}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,24}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,24}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,24}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,24}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,24}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,24}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,24}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,24}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,24}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,24}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,24}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,24}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,24}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,24}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,24}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,24}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,24}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,24}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,24}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,24}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,24}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,24}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,24}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,24}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,24}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,24}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing",{7,25}}

Names

GraphData[{"SmallestQuarticCrossing",{7,25}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,25}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,25}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,25}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,25}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,25}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,25}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,25}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,25}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,25}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,25}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,25}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,25}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,25}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,25}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,25}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,25}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,25}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,25}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,25}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,25}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,25}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,25}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,25}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,25}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,25}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,25}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,25}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,25}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,25}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,25}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,25}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,25}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,25}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,25}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,25}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,25}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,25}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,25}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,25}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,25}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,25}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,25}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,25}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,25}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,25}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,25}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,25}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,25}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,25}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,25}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,25}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,25}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,25}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing",{7,26}}

Names

GraphData[{"SmallestQuarticCrossing",{7,26}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,26}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,26}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,26}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,26}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,26}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,26}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,26}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,26}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,26}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,26}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,26}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,26}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,26}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,26}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,26}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,26}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,26}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,26}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,26}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,26}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,26}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,26}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,26}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,26}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,26}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,26}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,26}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,26}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,26}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,26}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,26}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,26}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,26}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,26}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,26}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,26}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,26}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,26}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,26}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,26}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,26}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,26}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,26}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,26}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,26}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,26}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,26}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,26}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,26}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,26}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,26}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,26}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,26}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing",{7,27}}

Names

GraphData[{"SmallestQuarticCrossing",{7,27}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,27}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,27}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,27}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,27}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,27}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,27}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,27}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,27}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,27}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,27}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,27}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,27}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,27}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,27}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,27}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,27}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,27}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,27}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,27}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,27}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,27}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,27}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,27}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,27}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,27}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,27}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,27}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,27}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,27}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,27}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,27}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,27}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,27}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,27}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,27}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,27}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,27}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,27}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,27}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,27}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,27}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,27}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,27}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,27}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,27}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,27}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,27}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,27}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,27}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,27}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,27}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,27}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,27}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing",{7,28}}

Names

GraphData[{"SmallestQuarticCrossing",{7,28}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,28}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,28}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,28}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,28}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,28}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,28}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,28}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,28}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,28}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,28}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,28}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,28}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,28}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,28}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,28}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,28}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,28}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,28}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,28}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,28}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,28}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,28}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,28}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,28}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,28}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,28}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,28}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,28}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,28}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,28}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,28}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,28}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,28}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,28}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,28}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,28}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,28}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,28}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,28}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,28}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,28}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,28}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,28}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,28}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,28}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,28}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,28}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,28}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,28}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,28}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,28}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,28}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,28}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 29}} == {"Cyclotomic", 13}

Names

GraphData[{"SmallestQuarticCrossing",{7,29}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,29}},"StandardNames"]

{"SmallestQuarticCrossing", {7, 30}}

Names

GraphData[{"SmallestQuarticCrossing",{7,30}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,30}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,30}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,30}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,30}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,30}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,30}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,30}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 7]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,30}}],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] RNPD 4, 2, 13, 6 succeeded
Date: 	Fri, 19 Sep 2025 23:04:10 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (RNPD 4, 2, 13, 6).
The graph has a crossing number of 7.

Please visit this link for detailed results: https://crossings.uos.de/job/XvRIh4rxQd_c0zw6V63ymA

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,30}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,30}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,30}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,30}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,30}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData["FolkmanGraph","V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,30}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,30}}],"CrossingNumber"->cn,RandomSeed->n],{n,100}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData["FolkmanGraph","V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,30}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

GraphReplot@

v={{-1,0},{1,0},{0,Sqrt[3]},{-2/3,1/4},{2/3,1/4},{-1/4,1/2},{1/4,1/2},{-1/6,3/4},{1/6,3/4},{-1/12,1},{1/12,1},{-1/8,5/4},{1/8,5/4}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[13,2,3,1,7,9,11,10,8,6,2,5,4,1,12,11],e[4,10,13],e[4,6,9],e[5,7,8],e[8,12,3,13,9],{5,11}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,30}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,30}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,30}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,30}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,30}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,30}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,30}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,30}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,30}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,30}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,30}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,30}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,30}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,30}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,30}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,30}}]]

Halin

GraphData[{"SmallestQuarticCrossing",{7,30}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,30}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,30}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,30}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,30}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,30}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,30}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,30}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,30}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,30}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,30}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,30}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,30}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,30}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,30}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,30}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,30}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 31}}

Names

GraphData[{"SmallestQuarticCrossing",{7,31}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,31}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embeddings

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,31}}]]

Default embedding

GraphPlot[Graph[GraphData[{"SmallestQuarticCrossing",{7,31}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,31}},"Edges"]]]

v={};
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

g=FindCorrespondingGraph[,v]

RecognizeGraph@g

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Degenerate"]

HouseOfGraphs

hogid=GraphData[{"SmallestQuarticCrossing",{7,31}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

HouseOfGraphsGraph[hogid]//StyleGraphs[#,ImageSize->Small]&

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Bilateral"]//StyleGraphs

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]//Quiet

Circular

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Circular"]//StyleGraphs

Circular construction

GraphData[{"SmallestQuarticCrossing",{7,31}},"Hamiltonian"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"HamiltonianCycleCount"]

Planar

GraphData[{"SmallestQuarticCrossing",{7,31}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,31}}],"DOT"]

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,31}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,31}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,31}}],Automatic,All,"Size"->Automatic,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,31}}],Automatic,All,"Size"->XXX,Method->"SubgraphIsomorphism",Debug->True]]//Timing

MaxMemoryUsed[]/10^9. GB

Tally[RectilinearCrossingCount/@gs]//Timing

Tally[RectilinearLocalCrossingCount/@gs]//Timing

GraphSymmetryGroup/@gs//Tally

Select[gs,GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]

Take[gs,UpTo[100]]

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,31}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,31}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,31}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,31}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,31}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,31}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,31}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,31}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,31}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,31}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,31}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,31}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,31}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,31}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"SmallestQuarticCrossing",{7,31}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"SmallestQuarticCrossing",{7,31}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"SmallestQuarticCrossing",{7,31}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,31}},"ComplementGraph","Name"]

GraphData[compl,"Graph","All"]

gs=GraphComplement/@%

Select[%,!DegenerateGraphEmbeddingQ[#]&]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,31}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,31}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"SmallestQuarticCrossing",{7,31}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,31}}]]

RecognizeGraph[%]

GraphData[roots[[1]],"Graph","All"]

gs=LineGraph/@%

Halin

GraphData[{"SmallestQuarticCrossing",{7,31}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,31}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,31}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,31}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,31}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,31}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,31}}],All])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,31}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,31}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","UnitDistance"]//StyleGraphs

Select[%,!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,31}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,31}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,31}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,31}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"SmallestQuarticCrossing",{7,31}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,31}}],TimeConstraint->300,"Results"->All]//Timing}

gs=SortBy[UniqueEmbeddings[l],Replace[RectilinearCrossingCount[#],Infinity->0]&]

Select[IndexGraph/@gs,!DegenerateGraphEmbeddingQ[#]&&GraphSymmetryGroup[#]=!=TransformationGroup[{}]&]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,31}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,31}},"Edges"]]

3D construction

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

3D All

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,31}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,31}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {7, 32}}

Names

GraphData[{"SmallestQuarticCrossing",{7,32}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"StandardNames"]

Primary

GraphData[{"SmallestQuarticCrossing",{7,32}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","All"]//StyleGraphs

Inexact

Select[GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","All"],(!FreeQ[GraphEmbedding[#],_?InexactNumberQ]&)]//StyleGraphs

Embedding types

GraphDataEmbeddings[GraphData[{"SmallestQuarticCrossing",{7,32}},"EdgeList"]]

Default embedding

GraphPlot[GraphData[{"SmallestQuarticCrossing",{7,32}},"Edges"],GraphLayout->"HighDimensionalEmbedding"]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Degenerate"]

Configuration

GraphData[{"SmallestQuarticCrossing",{7,32}},"Configuration"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Configuration"]//StyleGraphs

Perspective

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Perspective"]//StyleGraphs

HoneycombToroidal construction

GraphData[{"SmallestQuarticCrossing",{7,32}},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","IGraph"]//StyleGraphs

Bilateral

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"SmallestQuarticCrossing",{7,32}},"Planar"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,32}},{"RCN","CN"}]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->1,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->1,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->1,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->1,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->1,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 2

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->2,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->2,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->2,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->2,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->2,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->2,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber: "EmbeddingScheme" -> 3

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->3,TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->3,TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->3,TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->3,TimeConstraint->3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->3,TimeConstraint->5 3600])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],"EmbeddingScheme"->3,TimeConstraint->86400])//AbsoluteTiming

MinimalCrossingNumber crossings.uos.de [verified 7]

https://crossings.uos.de/job/new

ExportString[GraphData[{"SmallestQuarticCrossing",{7,32}}],"DOT"]

-------- Forwarded Message --------
Subject: 	[crossings.uos.de] SQC 7,32 succeeded
Date: 	Mon, 22 Sep 2025 15:38:46 +0200
From: 	confirm@vm524.rz.uni-osnabrueck.de
To: 	eww@wolfram.com
CC: 	mirwagner@uos.de, markus.chimani@uos.de

Dear Eric Weisstein,

we have successfully computed the crossing number of your graph (SQC 7,32).
The graph has a crossing number of 7.

Please visit this link for detailed results: https://crossings.uos.de/job/TEHR0G1H1thghFw26qF7uw

MinimalCrossing

GraphData[{"SmallestQuarticCrossing",{7,32}},"CN"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalRectilinearCrossing

GraphData[{"SmallestQuarticCrossing",{7,32}},"RCN"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],TimeConstraint->1])//AbsoluteTiming

Tutte:

(g=MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,32}}],"CrossingNumber"->cn])//PolyhedralGraphQ//AbsoluteTiming

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

TutteGraphs=BilateralGraph[CenterGraph@IGLayoutTutte[g,"OuterFace"->#],"ReturnNonbilateralGraph"->True]&/@faces

TutteGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,32}},"V"]])]
}&/@TutteGraphs;

Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[TutteGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

TutteGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,32}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@TutteGraphs;

DeleteCases[
TutteGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]

Random:

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,32}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union)//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"SmallestQuarticCrossing",{7,32}},"V"]])]
}&/@RandomGraphs;

Small numbers of crossing points on the boundary:

Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,0}:>g]

Select[Cases[RandomGraphsWithOuterCrossingPointCounts,{g_,1}:>g],Length[OuterFace[#]]>3&]

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[
#,
AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,32}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]/.g_Graph:>BilateralGraph[CenterGraph@g,"ReturnNonbilateralGraph"->True]

v={};
g=Graph[Range[Length[v]],UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,32}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"SmallestQuarticCrossing",{7,32}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

(cn=CrossingNumber[GraphData[{"SmallestQuarticCrossing",{7,32}}],TimeConstraint->10])//AbsoluteTiming

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,32}}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,32}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"SmallestQuarticCrossing",{7,32}}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"SmallestQuarticCrossing",{7,32}},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

GraphData[{"SmallestQuarticCrossing",{7,32}},"Circulant"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Circulant"]//StyleGraphs

Complement graph

compl=GraphData[{"SmallestQuarticCrossing",{7,32}},"ComplementGraph","Name"]

Line graph

GraphData[{"SmallestQuarticCrossing",{7,32}},"Line"]

LineGraphQ[GraphData[{"SmallestQuarticCrossing",{7,32}}]]//Timing

RootGraph

roots=Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"SmallestQuarticCrossing",{7,32}}&]

RootGraph[GraphData[{"SmallestQuarticCrossing",{7,32}}]]

RecognizeGraph[%]

Halin

GraphData[{"SmallestQuarticCrossing",{7,32}},"Halin"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"SmallestQuarticCrossing",{7,32}},"Rigid"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"SmallestQuarticCrossing",{7,32}},"Flexible"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"SmallestQuarticCrossing",{7,32}},"LCF"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"HamiltonianCycleCount"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"LCFSignature"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"LCFNotations"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","LCF"]//StyleGraphs

Tally[LCFNotation[#][[2]]&/@%]

LCF compute all

Divisors[GraphData[{"SmallestQuarticCrossing",{7,32}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"SmallestQuarticCrossing",{7,32}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"SmallestQuarticCrossing",{7,32}}],All])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

LCFGraph@@@Take[lcf,1]

LCFGraph@@@lcf//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,1])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,32}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"SmallestQuarticCrossing",{7,32}}],Debug->True]//Timing

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"SmallestQuarticCrossing",{7,32}},"VertexList"],GraphData[{"SmallestQuarticCrossing",{7,32}},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"SmallestQuarticCrossing",{7,32}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"SmallestQuarticCrossing",{7,32}},"Matchstick"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"SmallestQuarticCrossing",{7,32}},"Edges"]]

3D All

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"SmallestQuarticCrossing",{7,32}},"Polyhedral"]

GraphData[{"SmallestQuarticCrossing",{7,32}},"Graph",{"3D","Polyhedron"}]

{"SmallestQuarticCrossing", {8, 1}} == {"Circulant", {12, {2, 3}}}

Names

GraphData[{"SmallestQuarticCrossing",{8,1}},"StandardName"]

GraphData[{"SmallestQuarticCrossing",{8,1}},"StandardNames"]

Smallest Quartic Graphs with CN == n

FromGraphData

data=Monitor[GraphData[g=#,{"CN","V","#"}]&/@GraphData[{"Connected","Quartic"}],g];//Timing

tabledata=SplitBy[Sort[data],{First,#[[2]]&}]

Length/@Most[tabledata[[All,1]]]

TextGrid[smallest=Append[Take[#[[1]],2],Column@#[[All,-1]]]&/@Most[tabledata[[All,1]]],Dividers->All,Alignment->{{{Decimal},Left},Top}]

Missing minimal RCN embeddings

TextGrid[
Take[
DeleteCases[{#,#2,Select[#3[[1]],Function[f,FreeQ[GraphData[f,"EmbeddingClasses"],"MinimalCrossing"]]]}&@@@smallest,{_,_,{}}],
20
],
Dividers->All,Alignment->{{{Decimal},Left},Top}]

From files

<<MathWorld`Graphs`

Verify crossing numbers with different time constraints give the same result:

{#,Sort[FileBaseName/@#2],SameQ@@Get/@#2}&@@@Select[
Normal[GroupBy[FileNames["*.m",FileNameJoin[{$GraphDataDirectory,"Nodes","CrossingNumber","Quartic"}],Infinity],StringSplit[FileBaseName[#],"_"][[2]]&]],
Length[#[[2]]]>1&]//Column

AssembleSmallestRegularGraphs[deg_,files_,opts___?OptionQ]:=Module[
{
data=Get/@files,
max,
k,smallest,
vertexcounts=ToExpression[StringSplit[#,"_"][[2]]]&/@files,
debug=Lookup[{opts},Debug,False]
},
If[debug,Print["Found ",Length[data]," files"]];
max=Max[data];
If[debug,Print["Maximum crossing numbers across all files: ",max]];
smallest=Table[
With[{pos=FirstPosition[data,k,{Missing["NotFound"]}][[1]]},
{k,pos,If[MissingQ[pos],pos,Flatten@Position[data[[pos]],k]]}
],
{k,0,max}];
If[debug,Print["Positions and counts of smallest crossing number graphs:\n",smallest]];
{
#,
If[MissingQ[#2],#2,vertexcounts[[#2]]],
If[MissingQ[#3],#3,Length[#3]],
If[MissingQ[#2],{},RegularConnectedGraphs[deg,vertexcounts[[#2]]][[#3]]]
}&@@@smallest
]

smallest=AssembleSmallestRegularGraphs[
4,
FileNames["*.m",FileNameJoin[{$GraphDataDirectory,"Nodes","CrossingNumber","Quartic","2"}]],
Debug->True
]

TextGrid[
recognized=smallest/.g_Graph:>If[(rg=RecognizeGraph[g])==={},g,rg],
Dividers->All,Alignment->{{{Decimal},Left}}
]

Figure

style=Directive[FontFamily->Times,14];

GraphicsGrid[Partition[Annotate[
StyleGraphs@GraphData[#,"Graph","MinimalRectilinearCrossing"][[1]],
PlotLabel->Column[{
If[MissingQ[not=GraphData[#,"Notation"]],
Style[StringReplace[GraphData[#,"Name"],{"4\[Hyphen]regular "|"graph with "->"","number "->"#"}],style,Italic],
(* Else *)
Style[not/.s_String?(StringLength[#]==1&):>Style[s,Italic],style]
],
Style[Row[{"crossings: ",GraphData[#,"RCN"],", vertices: ",GraphData[#,"V"]}],style]
},
Alignment->Center]]&/@Select[
DeleteCases[Flatten[recognized[[All,-1]],1],_Graph],
!FreeQ[GraphData[#,"EmbeddingClasses"],"MinimalRectilinearCrossing"]&
],
UpTo[4]],
ImageSize->1000,Dividers->All,Alignment->Top]

Rename in V15

rules=MapIndexed[Rule[#[[2]],{#[[1]],#2[[2]]}]&,
Thread[{#,#4}]&@@@recognized,
{2}]

indexedclassrules=Select[Flatten[rules,1],FreeQ[_Graph]]

AddIndexedClass["SmallestQuarticCrossing",indexedclassrules,"15.0","AddClass"->False]

RenameGraphFiles[]

renamings={{"Quartic",{9,13}}->{"SmallestQuarticCrossing",{3,1}},{"Quartic",{9,15}}->{"SmallestQuarticCrossing",{3,3}},{"Quartic",{9,2}}->{"SmallestQuarticCrossing",{3,4}},{"RegularNonplanarDiameter",{4,2,12,22}}->{"SmallestQuarticCrossing",{6,10}},{"RegularNonplanarDiameter",{4,2,12,21}}->{"SmallestQuarticCrossing",{6,13}},{"RegularNonplanarDiameter",{4,2,13,8}}->{"SmallestQuarticCrossing",{7,23}},{"RegularNonplanarDiameter",{4,2,13,6}}->{"SmallestQuarticCrossing",{7,30}},{"RegularNonplanarDiameter",{4,2,13,4}}->{"SmallestQuarticCrossing",{7,32}}};

newgraphs=Select[Flatten[rules,1],!FreeQ[#,_Graph]&]

newgraphs={->{6,3},->{6,4},->{6,5},->{6,6},->{6,7},->{6,8},->{6,9},->{6,12},->{6,14},->{7,1},->{7,2},->{7,3},->{7,4},->{7,5},->{7,6},->{7,7},->{7,8},->{7,9},->{7,10},->{7,11},->{7,12},->{7,13},->{7,14},->{7,15},->{7,16},->{7,17},->{7,18},->{7,19},->{7,20},->{7,21},->{7,22},->{7,24},->{7,25},->{7,26},->{7,27},->{7,28},->{7,31}};

Position[newgraphs[[All,2]],{7,12}]

GraphData

GraphDataString

<<MathWorld`Graphs`

file=OpenAppend["~/smallest-quartic-crossing.m"]

WriteString[file,GraphDataString[#,
"StandardName"->{"SmallestQuarticCrossing",#2},
"Name"->"smallest quartic "<>ToString[#2[[1]]]<>"\[Hyphen]crossing graph "<>ToString[#2[[2]]],
"Embeddings"->None,
"Classes"->{"SmallestQuarticCrossing"->#2},
"Information"->"SmallestQuarticCrossingNumberGraph",
"Skip"->{"ConstructionNumber","CyclicEdgeCuts","EdgeCovers","EdgeCuts","ErdosSequence","Minors","PinnacleSets"},
TimeConstraint->10
]]&@@@Take[newgraphs,{-2}];

Close[file]