Paulus Graphs

Author

Eric W. Weisstein
January 16, 2023

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

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

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

Enumeration

25-Paulus

Union[GraphData[#,"RegularParameters"]&/@GraphData["Paulus",25]]

GraphicsGrid[paulus25=Partition[GraphData/@GraphData["Paulus",25],UpTo[8]],ImageSize->500]//StyleGraphs

GraphData["Paulus",25]

GraphData[{"Paley",25},"StandardNames"]

Select[GraphData["StronglyRegular"],Flatten@GraphData[#,"RegularParameters"]==={25,12,5,6}&]

Length[%]

26-Paulus

Union[GraphData[#,"RegularParameters"]&/@GraphData["Paulus",26]]

GraphicsGrid[paulus26=Partition[GraphData/@GraphData["Paulus",26],UpTo[8]],ImageSize->500]//StyleGraphs

GraphData["Paulus",26]

Select[GraphData["StronglyRegular"],Flatten@GraphData[#,"RegularParameters"]==={26,10,3,4}&]

Length[%]

Figure

GraphicsGrid[Join[paulus25,paulus26]//StyleGraphs,ImageSize->700,Dividers->{{True,{False},True},{True,False,True,False,True}}]

Distance-Regular

GraphData[#,"DistanceRegular"]&/@GraphData["Paulus"]

Embeddings

25

<<MathWorld`Graphs`

{"Paulus", {25, 1}}

GraphData[{"Paulus",{25,1}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,1}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,1}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,1}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,1}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,1}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,1}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,1}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,1}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,1}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,1}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,1}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,1}},"LCF"]

GraphData[{"Paulus",{25,1}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,1}},"LCFSignature"]

GraphData[{"Paulus",{25,1}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,1}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,1}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,1}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,1}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,1}},"VertexList"],GraphData[{"Paulus",{25,1}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,1}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,1}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,1}},"Polyhedral"]

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

{"Paulus", {25, 2}}

GraphData[{"Paulus",{25,2}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,2}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,2}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,2}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,2}},{"RCN","CN"}]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Paulus",{25,2}}],TimeConstraint->1])//AbsoluteTiming

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,2}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,2}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,2}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,2}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,2}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,2}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,2}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,2}},"LCF"]

GraphData[{"Paulus",{25,2}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,2}},"LCFSignature"]

GraphData[{"Paulus",{25,2}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,2}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,2}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,2}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,2}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,2}},"VertexList"],GraphData[{"Paulus",{25,2}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,2}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,2}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,2}},"Polyhedral"]

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

{"Paulus", {25, 3}}

GraphData[{"Paulus",{25,3}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,3}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,3}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,3}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,3}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,3}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,3}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,3}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,3}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,3}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,3}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,3}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,3}},"LCF"]

GraphData[{"Paulus",{25,3}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,3}},"LCFSignature"]

GraphData[{"Paulus",{25,3}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,3}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,3}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,3}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,3}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,3}},"VertexList"],GraphData[{"Paulus",{25,3}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,3}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,3}},"Edges"]]

3D All

GraphData[{"Paulus",{25,3}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Paulus",{25,3}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Paulus",{25,3}},"Polyhedral"]

GraphData[{"Paulus",{25,3}},"Graph",{"3D","Polyhedron"}]

{"Paulus", {25, 4}}

GraphData[{"Paulus",{25,4}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,4}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,4}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,4}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,4}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,4}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,4}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,4}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,4}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,4}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,4}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,4}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,4}},"LCF"]

GraphData[{"Paulus",{25,4}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,4}},"LCFSignature"]

GraphData[{"Paulus",{25,4}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,4}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,4}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,4}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,4}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,4}},"VertexList"],GraphData[{"Paulus",{25,4}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,4}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,4}},"Polyhedral"]

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

{"Paulus", {25, 5}}

GraphData[{"Paulus",{25,5}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,5}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,5}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,5}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,5}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,5}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,5}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,5}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,5}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,5}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,5}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,5}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,5}},"LCF"]

GraphData[{"Paulus",{25,5}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,5}},"LCFSignature"]

GraphData[{"Paulus",{25,5}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,5}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,5}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,5}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,5}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,5}},"VertexList"],GraphData[{"Paulus",{25,5}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,5}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,5}},"Polyhedral"]

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

{"Paulus", {25, 6}}

GraphData[{"Paulus",{25,6}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,6}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,6}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,6}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,6}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,6}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,6}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,6}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,6}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,6}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,6}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,6}},"LCF"]

GraphData[{"Paulus",{25,6}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,6}},"LCFSignature"]

GraphData[{"Paulus",{25,6}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,6}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,6}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,6}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,6}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,6}},"VertexList"],GraphData[{"Paulus",{25,6}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,6}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,6}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,6}},"Polyhedral"]

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

{"Paulus", {25, 7}}

GraphData[{"Paulus",{25,7}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,7}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,7}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,7}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,7}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,7}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,7}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,7}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,7}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,7}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,7}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,7}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,7}},"LCF"]

GraphData[{"Paulus",{25,7}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,7}},"LCFSignature"]

GraphData[{"Paulus",{25,7}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,7}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,7}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,7}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,7}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,7}},"VertexList"],GraphData[{"Paulus",{25,7}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,7}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,7}},"Polyhedral"]

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

{"Paulus", {25, 8}}

GraphData[{"Paulus",{25,8}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,8}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,8}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"Paulus",{25,8}},"Planar"]

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

MinimalCrossing

GraphData[{"Paulus",{25,8}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,8}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,8}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,8}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,8}},"Circulant"]

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

Halin

GraphData[{"Paulus",{25,8}},"Halin"]

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

Rigid

GraphData[{"Paulus",{25,8}},"Rigid"]

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

Flexible

GraphData[{"Paulus",{25,8}},"Flexible"]

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

LCF

GraphData[{"Paulus",{25,8}},"LCF"]

GraphData[{"Paulus",{25,8}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,8}},"LCFSignature"]

GraphData[{"Paulus",{25,8}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,8}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,8}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,8}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,8}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,8}},"VertexList"],GraphData[{"Paulus",{25,8}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"Paulus",{25,8}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Paulus",{25,8}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,8}},"Polyhedral"]

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

{"Paulus", {25, 9}}

GraphData[{"Paulus",{25,9}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,9}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,9}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Paulus",{25,9}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Paulus",{25,9}},"Graph","Degenerate"]

Bilateral

GraphData[{"Paulus",{25,9}},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

GraphData[{"Paulus",{25,9}},"Planar"]

GraphData[{"Paulus",{25,9}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Paulus",{25,9}},{"RCN","CN"}]

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Paulus",{25,9}}],TimeConstraint->1])//AbsoluteTiming

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,9}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,9}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,9}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,9}},"Circulant"]

GraphData[{"Paulus",{25,9}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Paulus",{25,9}},"Halin"]

GraphData[{"Paulus",{25,9}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Paulus",{25,9}},"Rigid"]

GraphData[{"Paulus",{25,9}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Paulus",{25,9}},"Flexible"]

GraphData[{"Paulus",{25,9}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Paulus",{25,9}},"LCF"]

GraphData[{"Paulus",{25,9}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,9}},"LCFSignature"]

GraphData[{"Paulus",{25,9}},"LCFNotations"]

GraphData[{"Paulus",{25,9}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,9}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,9}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,9}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,9}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Paulus",{25,9}}],Debug->True]//Timing

GraphData[{"Paulus",{25,9}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,9}},"VertexList"],GraphData[{"Paulus",{25,9}},"EdgeList"]]]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]]]&/@Complement@@(GraphData[{"Paulus",{25,9}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Paulus",{25,9}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Paulus",{25,9}},"Matchstick"]

GraphData[{"Paulus",{25,9}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Paulus",{25,9}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Paulus",{25,9}},"Polyhedral"]

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

{"Paulus", {25, 10}}

GraphData[{"Paulus",{25,10}},"StandardName"]

Primary

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

All

GraphData[{"Paulus",{25,10}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,10}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,10}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Paulus",{25,10}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Paulus",{25,10}},"Graph","Degenerate"]

Bilateral

GraphData[{"Paulus",{25,10}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Paulus",{25,10}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Paulus",{25,10}},"Planar"]

GraphData[{"Paulus",{25,10}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Paulus",{25,10}},{"RCN","CN"}]

GraphData[{"Paulus",{25,10}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,10}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,10}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,10}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,10}},"Circulant"]

GraphData[{"Paulus",{25,10}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Paulus",{25,10}},"Halin"]

GraphData[{"Paulus",{25,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Paulus",{25,10}},"Rigid"]

GraphData[{"Paulus",{25,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Paulus",{25,10}},"Flexible"]

GraphData[{"Paulus",{25,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Paulus",{25,10}},"LCF"]

GraphData[{"Paulus",{25,10}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,10}},"LCFSignature"]

GraphData[{"Paulus",{25,10}},"LCFNotations"]

GraphData[{"Paulus",{25,10}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,10}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,10}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,10}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Paulus",{25,10}}],Debug->True]//Timing

GraphData[{"Paulus",{25,10}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,10}},"VertexList"],GraphData[{"Paulus",{25,10}},"EdgeList"]]]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]]]&/@Complement@@(GraphData[{"Paulus",{25,10}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Paulus",{25,10}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Paulus",{25,10}},"Matchstick"]

GraphData[{"Paulus",{25,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Paulus",{25,10}},"Edges"]]

3D All

GraphData[{"Paulus",{25,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Paulus",{25,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Paulus",{25,10}},"Polyhedral"]

GraphData[{"Paulus",{25,10}},"Graph",{"3D","Polyhedron"}]

{"Paulus", {25, 11}}

GraphData[{"Paulus",{25,11}},"StandardName"]

Primary

GraphData[{"Paulus",{25,11}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Paulus",{25,11}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,11}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,11}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Paulus",{25,11}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Paulus",{25,11}},"Graph","Degenerate"]

Bilateral

GraphData[{"Paulus",{25,11}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Paulus",{25,11}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Paulus",{25,11}},"Planar"]

GraphData[{"Paulus",{25,11}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Paulus",{25,11}},{"RCN","CN"}]

GraphData[{"Paulus",{25,11}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Paulus",{25,11}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,11}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,11}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,11}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,11}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,11}},"Circulant"]

GraphData[{"Paulus",{25,11}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Paulus",{25,11}},"Halin"]

GraphData[{"Paulus",{25,11}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Paulus",{25,11}},"Rigid"]

GraphData[{"Paulus",{25,11}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Paulus",{25,11}},"Flexible"]

GraphData[{"Paulus",{25,11}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Paulus",{25,11}},"LCF"]

GraphData[{"Paulus",{25,11}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,11}},"LCFSignature"]

GraphData[{"Paulus",{25,11}},"LCFNotations"]

GraphData[{"Paulus",{25,11}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,11}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,11}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,11}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,11}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Paulus",{25,11}}],Debug->True]//Timing

GraphData[{"Paulus",{25,11}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,11}},"VertexList"],GraphData[{"Paulus",{25,11}},"EdgeList"]]]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]]]&/@Complement@@(GraphData[{"Paulus",{25,11}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Paulus",{25,11}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Paulus",{25,11}},"Matchstick"]

GraphData[{"Paulus",{25,11}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Paulus",{25,11}},"Edges"]]

3D All

GraphData[{"Paulus",{25,11}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Paulus",{25,11}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Paulus",{25,11}},"Polyhedral"]

GraphData[{"Paulus",{25,11}},"Graph",{"3D","Polyhedron"}]

{"Paulus", {25, 12}}

GraphData[{"Paulus",{25,12}},"StandardName"]

Primary

GraphData[{"Paulus",{25,12}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Paulus",{25,12}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,12}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,12}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Paulus",{25,12}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Paulus",{25,12}},"Graph","Degenerate"]

Bilateral

GraphData[{"Paulus",{25,12}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Paulus",{25,12}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Paulus",{25,12}},"Planar"]

GraphData[{"Paulus",{25,12}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Paulus",{25,12}},{"RCN","CN"}]

GraphData[{"Paulus",{25,12}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Paulus",{25,12}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,12}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,12}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,12}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,12}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,12}},"Circulant"]

GraphData[{"Paulus",{25,12}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Paulus",{25,12}},"Halin"]

GraphData[{"Paulus",{25,12}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Paulus",{25,12}},"Rigid"]

GraphData[{"Paulus",{25,12}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Paulus",{25,12}},"Flexible"]

GraphData[{"Paulus",{25,12}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Paulus",{25,12}},"LCF"]

GraphData[{"Paulus",{25,12}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,12}},"LCFSignature"]

GraphData[{"Paulus",{25,12}},"LCFNotations"]

GraphData[{"Paulus",{25,12}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,12}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,12}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,12}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,12}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Paulus",{25,12}}],Debug->True]//Timing

GraphData[{"Paulus",{25,12}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,12}},"VertexList"],GraphData[{"Paulus",{25,12}},"EdgeList"]]]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]]]&/@Complement@@(GraphData[{"Paulus",{25,12}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Paulus",{25,12}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Paulus",{25,12}},"Matchstick"]

GraphData[{"Paulus",{25,12}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Paulus",{25,12}},"Edges"]]

3D All

GraphData[{"Paulus",{25,12}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Paulus",{25,12}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Paulus",{25,12}},"Polyhedral"]

GraphData[{"Paulus",{25,12}},"Graph",{"3D","Polyhedron"}]

{"Paulus", {25, 13}}

GraphData[{"Paulus",{25,13}},"StandardName"]

Primary

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

All

GraphData[{"Paulus",{25,13}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,13}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,13}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Paulus",{25,13}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Paulus",{25,13}},"Graph","Degenerate"]

Bilateral

GraphData[{"Paulus",{25,13}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Paulus",{25,13}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Paulus",{25,13}},"Planar"]

GraphData[{"Paulus",{25,13}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Paulus",{25,13}},{"RCN","CN"}]

GraphData[{"Paulus",{25,13}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Paulus",{25,13}}],TimeConstraint->1])//AbsoluteTiming

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

(cn=CrossingNumber[GraphData[{"Paulus",{25,13}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,13}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,13}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,13}},"Circulant"]

GraphData[{"Paulus",{25,13}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Paulus",{25,13}},"Halin"]

GraphData[{"Paulus",{25,13}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Paulus",{25,13}},"Rigid"]

GraphData[{"Paulus",{25,13}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Paulus",{25,13}},"Flexible"]

GraphData[{"Paulus",{25,13}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Paulus",{25,13}},"LCF"]

GraphData[{"Paulus",{25,13}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,13}},"LCFSignature"]

GraphData[{"Paulus",{25,13}},"LCFNotations"]

GraphData[{"Paulus",{25,13}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,13}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,13}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,13}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,13}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Paulus",{25,13}}],Debug->True]//Timing

GraphData[{"Paulus",{25,13}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,13}},"VertexList"],GraphData[{"Paulus",{25,13}},"EdgeList"]]]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]]]&/@Complement@@(GraphData[{"Paulus",{25,13}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Paulus",{25,13}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Paulus",{25,13}},"Matchstick"]

GraphData[{"Paulus",{25,13}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Paulus",{25,13}},"Edges"]]

3D All

GraphData[{"Paulus",{25,13}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Paulus",{25,13}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Paulus",{25,13}},"Polyhedral"]

GraphData[{"Paulus",{25,13}},"Graph",{"3D","Polyhedron"}]

{"Paulus", {25, 14}}

GraphData[{"Paulus",{25,14}},"StandardName"]

Primary

GraphData[{"Paulus",{25,14}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Paulus",{25,14}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Paulus",{25,14}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Paulus",{25,14}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"Paulus",{25,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"Paulus",{25,14}},"Graph","Degenerate"]

Bilateral

GraphData[{"Paulus",{25,14}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"Paulus",{25,14}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Paulus",{25,14}},"Planar"]

GraphData[{"Paulus",{25,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"Paulus",{25,14}},{"RCN","CN"}]

GraphData[{"Paulus",{25,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"Paulus",{25,14}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,14}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,14}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"Paulus",{25,14}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"Paulus",{25,14}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Paulus",{25,14}},"Circulant"]

GraphData[{"Paulus",{25,14}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Paulus",{25,14}},"Halin"]

GraphData[{"Paulus",{25,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"Paulus",{25,14}},"Rigid"]

GraphData[{"Paulus",{25,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"Paulus",{25,14}},"Flexible"]

GraphData[{"Paulus",{25,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"Paulus",{25,14}},"LCF"]

GraphData[{"Paulus",{25,14}},"HamiltonianCycleCount"]

GraphData[{"Paulus",{25,14}},"LCFSignature"]

GraphData[{"Paulus",{25,14}},"LCFNotations"]

GraphData[{"Paulus",{25,14}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"Paulus",{25,14}},2,TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Paulus",{25,14}}],10^5])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Paulus",{25,14}}],10^7])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

UnitDistance

GraphData[{"Paulus",{25,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Paulus",{25,14}}],Debug->True]//Timing

GraphData[{"Paulus",{25,14}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Paulus",{25,14}},"VertexList"],GraphData[{"Paulus",{25,14}},"EdgeList"]]]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]]]&/@Complement@@(GraphData[{"Paulus",{25,14}},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"Paulus",{25,14}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"Paulus",{25,14}},"Matchstick"]

GraphData[{"Paulus",{25,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"Paulus",{25,14}},"Edges"]]

3D All

GraphData[{"Paulus",{25,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Paulus",{25,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Paulus",{25,14}},"Polyhedral"]

GraphData[{"Paulus",{25,14}},"Graph",{"3D","Polyhedron"}]

{"Paulus", {25, 15}} == {"Paley", 25}

GraphData[{"Paulus",{25,15}},"StandardName"]

GraphData

GraphClassString

GraphData["Paulus*"]

GraphClassString[GraphData["Paulus*"]]