Arc-Transitive Graph

Author

Eric W. Weisstein
May 8, 2026

This notebook downloaded from https://mathworld.wolfram.com/notebooks/GraphTheory/Arc-TransitiveGraph.nb.

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

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

Classes

GraphClassesThatAre["ArcTransitive"]

ArcTransitive but not EdgeTransitive

Complement@@GraphData/@{"ArcTransitive","EdgeTransitive"}

ArcTransitive but not Regular

Complement@@GraphData/@{"ArcTransitive","Regular"}

ArcTransitive but not VertexTransitive

Complement@@GraphData/@{"ArcTransitive","VertexTransitive"}

EdgeTransitive but not ArcTransitive

SortBy[
Complement@@GraphData/@{"EdgeTransitive","ArcTransitive","Disconnected"},
GraphData[#,"V"]&
]

EdgeTransitive + Regular but not ArcTransitive

SortBy[
Complement@@GraphData/@{{"Regular","EdgeTransitive"},"ArcTransitive","Empty"},
GraphData[#,"V"]&
]

Symmetric but not ArcTransitive

SortBy[
Complement@@GraphData/@{"Symmetric","ArcTransitive","Empty"},
GraphData[#,"V"]&
]

VertexTransitive but not ArcTransitive

Complement@@GraphData/@{"VertexTransitive","ArcTransitive","Disconnected"}

Arc-transitivity counts

(Tally[Sort[#]]&/@(values=Table[ArcTransitivity/@Graphs[n],{n,8}]))//Column

SetDirectory["/Users/eww/Documents/Mathematica/Paclets/GraphData/Nodes"];

(tallies=Tally[DeleteCases[Sort[#],$Failed|Infinity]][[All,2]]&/@(values=Get/@FileNames["*.m","ArcTransitivity"]))//Column

Flatten[tallies]

Counts

All

A180240

Count[Get[#],_?(Function[a,a>0])]&/@FileNames["*.m",FileNameJoin[{$GraphDataDirectory,"Nodes","ArcTransitivity"}]]

Table[Total[Boole[ArcTransitiveGraphQ/@Graphs[n]]],{n,10}]//Timing

Table[Length@GraphData["ArcTransitive",n],{n,10}]

Length[seq={0,1,1,3,2,6,2,8,5,11,2,19,4,11,13,23,4,24,3,35,16,11,2,58,13,18,25,39,4,67,4}]

Length/@Table[GraphData["ArcTransitive",n],{n,31}]

seq-%

Position[%73,Except[0,_Integer]]//Flatten

Missing 4 graphs of order 18?

Monitor[Length/@Table[Import["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/VertexTransitive/All/trans"<>(dig=If[i<10,"0",""]<>ToString[i])<>"/trans"<>dig<>".g6","AdjacencyMatrix"],{i,2,31}],i]//Timing

Monitor[Length/@Table[Select[Import["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/VertexTransitive/All/trans"<>(dig=If[i<10,"0",""]<>ToString[i])<>"/trans"<>dig<>".g6","AdjacencyMatrix"],ArcTransitiveQ[AdjacencyGraph[#]]&],{i,31}],i]//Timing

Grid[Table[{n,GraphData[#,"Name"]&/@GraphData["ArcTransitive",n]},{n,2,8}],Alignment->{Left,Automatic},Dividers->All]//TraditionalForm

6

file=OpenRead["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/McKay/graph6.g6"]

Monitor[Do[If[at=ArcTransitiveQ[g=ImportString[Read[file,"String"],"Graph6"]],Print[{i,RecognizeGraph[g],at}]],{i,156}],i];//Timing

Close[file]

7

file=OpenRead["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/McKay/graph7.g6"]

Monitor[Do[If[at=ArcTransitiveQ[g=ImportString[Read[file,"String"],"Graph6"]],Print[{i,RecognizeGraph[g],at}]],{i,1044}],i];//Timing

Close[file]

8

Length[g=Graphs[8]]

Monitor[Do[If[at=ArcTransitiveQ[g[[i]]],Print[{i,RecognizeGraph[GetGraph[{8,i}]],at}]],{i,Length[g]}],i];//Timing

9

Length[g=Graphs[9]]

Monitor[Do[If[at=ArcTransitiveQ[g[[i]]],Print[{i,RecognizeGraph[GetGraph[{9,i}]],at}]],{i,Length[g]}],i];//Timing

Select[GraphData["VertexTransitive",9],ArcTransitiveQ[GraphData[#]]&]

Length[%]

10

file=OpenRead["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/McKay/graph10.g6"]

Monitor[Do[If[at=ArcTransitiveQ[g=ImportString[Read[file,"String"],"Graph6"]],Print[{i,RecognizeGraph[g],at}]],{i,12005168}],i];//Timing

Close[file]

Select[GraphData["VertexTransitive",10],ArcTransitiveQ[GraphData[#]]&]

Length[%]

Connected

A286280

Table[Total[Boole[ArcTransitiveGraphQ/@ConnectedGraphs[n]]],{n,10}]//Timing

at=Length/@Table[GraphData[{"Connected","ArcTransitive"},n],{n,30}]

Length[oeis={0,1,1,2,2,4,2,5,4,8,2,11,4,8,10,15,4,14,3,22,13,8,2,34,11,13,20,26,4,41}]

oeis-at

Position[%,Except[0,_Integer]]//Flatten

Position[%,Except[0|2,_Integer]]//Flatten

Connected Symmetric

sym=Length/@Table[GraphData[{"Connected","Symmetric"},n],{n,30}]

Symmetric non-arc-transitive

sym-at

Position[%,Except[0,_Integer]]//Flatten

TextGrid[Sort[GraphData[#,{"V","#"}]&/@(Complement@@GraphData/@{"Symmetric","ArcTransitive","Disconnected"})],Dividers->All,Alignment->{{Decimal,Left}}]

Disconnected

Not in OEIS?

all={0,1,1,3,2,6,2,8,5,11,2,19,4,11,13,23,4,24,3,35,16,11,2,58,13,18,25,39,4,67,4};
con={0,1,1,2,2,4,2,5,4,8,2,11,4,8,10,15,4,14,3,22,13,8,2,34,11,13,20,26,4,41};

Length/@{all,con}

Take[all,30]-con

Table[Length@GraphData[{"ArcTransitive","Disconnected"},n],{n,10}]

Table

New Table

table=(#[[1,1]]->#[[All,2]])&/@SplitBy[SortBy[GraphData[#,{"ArcTransitivity","#"}]&/@GraphData["ArcTransitive"],First],First]

Old Table

TableForm[(uni=Sort[{GraphData[#,"Unitransitivity"],GraphData[#,"V"],GraphData[#,"Degrees"]//Union,GraphData[#,"#"]}&/@GraphData["Unitransitive"]]),TableDepth->2]

TableForm[(uni=Sort[{GraphData[#,"Unitransitivity"],GraphData[#,"V"],GraphData[#,"Degrees"]//Union,GraphData[#,"#"]}&/@Union[Append[GraphData["Unitransitive"],"Foster432C"]]/.Missing["NotApplicable"]->1]),TableDepth->2]

uni2=Select[uni[[All,-1]],GraphData[#,"Embeddings"]=!={}&]

GraphicsGrid[Partition[Show[GraphData[#],PlotLabel->TextCell[Column[{s==GraphData[#,"Unitransitivity"],GraphData[#,"Name"]},Alignment->Center,Spacings->.1],PageWidth->100,TextAlignment->Center],BaseStyle->{10,Italic}]&/@uni2,4,4,{1,1},{}],ImageSize->400,Spacings->{-20,40}]

Condor's database of connected arc-transitive graphs up to 30 nodes

CondorConnectedArcTransitiveGraphs[n_,opts___?OptionQ]:=Module[{
debug=Lookup[{opts},Debug,False],
data=Import["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/Condor/symmetricgraphs-orderupto30.txt","String"],
matchstr="Symmetric graph "~~DigitCharacter..~~" of order "<>ToString[n],
ss,adjlists
},
If[debug,Print[StringCases[data,matchstr]]];
ss=StringSplit[data,"........................................................................"];
adjlists=Select[StringSplit[#,"\n"],!StringFreeQ[#,";"]&]&/@Rest@StringSplit[SelectFirst[ss,!StringFreeQ[#,matchstr]&],matchstr];
Check[SimpleGraph[FromAdjacencyLists[ImportString[StringRiffle[#,"\n"],"Table"][[All,2;;-2]]]],$Failed]&/@adjlists//Quiet
]

A286280

{0,1,1,2,2,4,2,5,4,8,2,11,4,8,10,15,4,14,3,22,13,8,2,34,11,13,20,26,4,41}

2-node connected [1]

at=CondorConnectedArcTransitiveGraphs[n=2]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

3-node connected [1]

at=CondorConnectedArcTransitiveGraphs[n=3]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

4-node connected [2]

at=CondorConnectedArcTransitiveGraphs[n=4]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

5-node connected [2]

at=CondorConnectedArcTransitiveGraphs[n=5]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

6-node connected [4]

at=CondorConnectedArcTransitiveGraphs[n=6]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

7-node connected [2]

at=CondorConnectedArcTransitiveGraphs[n=7]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

8-node connected [5]

at=CondorConnectedArcTransitiveGraphs[n=8]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

9-node connected [4]

at=CondorConnectedArcTransitiveGraphs[n=9]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

10-node connected [8]

at=CondorConnectedArcTransitiveGraphs[n=10]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

11-node connected [2]

at=CondorConnectedArcTransitiveGraphs[n=11]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

12-node connected [11]

at=CondorConnectedArcTransitiveGraphs[n=12]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

13-node connected [4]

at=CondorConnectedArcTransitiveGraphs[n=13]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

14-node connected [8]

at=CondorConnectedArcTransitiveGraphs[n=14]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

15-node connected [10]

at=CondorConnectedArcTransitiveGraphs[n=15]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

16-node connected [15]

at=CondorConnectedArcTransitiveGraphs[n=16]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

17-node connected [4]

at=CondorConnectedArcTransitiveGraphs[n=17]

gs={#,RecognizeGraph[#]}&/@at

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

18-node connected [14]

https://www.math.auckland.ac.nz/~conder/symmetricgraphs-orderupto30.txt

https://oeis.org/A286280

$Version

data=Import["https://www.math.auckland.ac.nz/~conder/symmetricgraphs-orderupto30.txt","String"];

Internal`$LastInternalFailure

at18=CondorConnectedArcTransitiveGraphs[18]

gs={#,RecognizeGraph[#]}&/@at18

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{18,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{"18\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

Length[gs]

Sort@GraphData[{"ArcTransitive","Connected"},18]==Sort[gs]

GraphData[{"ArcTransitive","Connected"},18]//Length

GraphData["ArcTransitive",18]//Length

19-node connected [3]

at=CondorConnectedArcTransitiveGraphs[n=19]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

20-node connected [22]

at=CondorConnectedArcTransitiveGraphs[n=20]

gs={#,RecognizeGraph[#]}&/@at

Length[gs]

Cases[gs,{g_,{}}:>g]

l=MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

21-node connected [13]

at=CondorConnectedArcTransitiveGraphs[n=21]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=Cases[gs,{g_,{},gn_}:>{g,gn}]

l=Cases[
MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

22-node connected [8]

at=CondorConnectedArcTransitiveGraphs[n=22]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

23-node connected [2]

at=CondorConnectedArcTransitiveGraphs[n=23]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

24-node connected [34]

at=CondorConnectedArcTransitiveGraphs[n=24]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

25-node connected [11]

at=CondorConnectedArcTransitiveGraphs[n=25]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

26-node connected [13]

at=CondorConnectedArcTransitiveGraphs[n=26]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

27-node connected [20]

at=CondorConnectedArcTransitiveGraphs[n=27]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

28-node connected [26]

at=CondorConnectedArcTransitiveGraphs[n=28]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=Cases[gs,{g_,{},gn_}:>{g,gn}]

missing=Select[gs,FreeQ[GraphData[#[[2]],"StandardNames"],#[[3]]]&]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Union@Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames",Select[$Subdirs,ToExpression[#]>=13&]]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames",Select[$Subdirs,ToExpression[#]>=13&]]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[DeleteCases[GraphData[#[[2]],"NotationRules"],HoldPattern[Rule["ArcTransitive",_]]],{"ArcTransitive"->{n,#2[[1]]}}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"NotationRules",Select[$Subdirs,ToExpression[#]>=13&]]

RenameGraphFiles[]

29-node connected [4]

at=CondorConnectedArcTransitiveGraphs[n=29]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

30-node connected [41]

at=CondorConnectedArcTransitiveGraphs[n=30]

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

l=Cases[MapIndexed[{#[[2]],{0,SortBy[Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l,"AlternateStandardNames","12.4"]

RenameGraphFiles[]

l2=Cases[MapIndexed[{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}&,gs],{{"Complete"|"Cycle",_},_}]

PropertyReplace[l2,"AlternateNames","12.4"]

RenameGraphFiles[]

31-node connected [>= 4; from Royle's VT list]

Length[vt=Import["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/Royle/VertexTransitive/trans31c.g6"]]//Timing//AbsoluteTiming

i=0;
Length[at=Monitor[Select[vt,ArcTransitiveGraphQ[i++;#]&],i]]//Timing

n=31;

gs=MapIndexed[{#,RecognizeGraph[#],{"ArcTransitive",{n,#2[[1]]}}}&,at]

Length[gs]

new=DeleteCases[Cases[gs,{g_,{},gn_}:>{g,gn}],{_?(CycleGraphQ[#]||CompleteGraphQ[#]&),__}]

new={{,{"ArcTransitive",{31,2}}}};

CirculantGraphQ/@new[[All,1]]

l=MapIndexed[If[#[[2]]==={},Nothing,{#[[2]],{0,SortBy[Union@Append[GraphData[#[[2]],"AlternateStandardNames"],{"ArcTransitive",{n,#2[[1]]}}],First[Flatten[{#}]]&]}}]&,gs]

PropertyReplace[l,"AlternateStandardNames",Select[$Subdirs,ToExpression[#]>=13&]]

RenameGraphFiles[]

l2=MapIndexed[If[#[[2]]==={},Nothing,{#[[2]],{0,Union[GraphData[#[[2]],"AlternateNames"],{ToString[n]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[1]]]}]}}]&,gs]

PropertyReplace[l2,"AlternateNames",Select[$Subdirs,ToExpression[#]>=13&]]

RenameGraphFiles[]

l3=MapIndexed[If[#[[2]]==={},Nothing,{#[[2]],{0,Union[DeleteCases[GraphData[#[[2]],"NotationRules"],HoldPattern[Rule["ArcTransitive",_]]],{"ArcTransitive"->{n,#2[[1]]}}]}}]&,gs]

PropertyReplace[l3,"NotationRules",Select[$Subdirs,ToExpression[#]>=13&]]

RenameGraphFiles[]

Frucht24 = NauruGraph

UndirectedGraph[CayleyGraph[PermutationGroup[PermutationCycles/@{{2,1,3,4},{3,2,1,4},{4,2,3,1}}]]]//RecognizeGraph

Frucht64 = Foster064A

UndirectedGraph[CayleyGraph[PermutationGroup[PermutationCycles/@{{2,1,4,3,5,6,7,8,11,10,9,12},{3,2,1,4,6,5,8,7,9,10,11,12},{1,2,3,4,7,6,5,8,10,9,12,11}}]]]//RecognizeGraph

Frucht432 = Foster432C

UndirectedGraph[CayleyGraph[PermutationGroup[PermutationCycles/@{{2,1,5,8,3,6,7,4,9},{3,6,1,4,9,2,7,8,5},{4,3,2,1,5,7,6,8,9}}]]]//RecognizeGraph

Construction: disconnected

https://oeis.org/A180240

connected={0,1,1,2,2,4,2,5,4,8,2,11,4,8,10,15,4,14,3,22,13,8,2,34,11,13,20,26,4,41};

oeis={0,1,1,3,2,6,2,8,5,11,2,19,4,11,13,23,4,24,3,35,16,11,2,58,13,18,25,39,4,67};

all=Length/@Table[GraphData["ArcTransitive",n],{n,30}]

oeis-all

Position[%,Except[0,_Integer]]//Flatten

18-node disconnected [10]

GraphData[{"Disconnected","ArcTransitive"},18]//Length

GraphData[{"Disconnected","ArcTransitive"},18]

GraphData[{"ArcTransitive","Connected"},9]

g=MyGraphUnion[GraphData[{"GeneralizedQuadrangle",{2,1}}],2]

RecognizeGraph[g]

Algorithm

Faster

ArcTransitiveQ[g_System`Graph]:=Module[{
auto=AutomorphismGroup[g],
arcs=Join[#,Reverse/@#]&[List@@@EdgeList[g]],
orbs
},
orbs=GroupOrbits[auto,arcs[[{1}]],Function[v,PermutationReplace[v,#2]]/@#1&];
Sort[orbs]=={Sort[arcs]}
]

ArcTransitiveQ[GraphData[{"Triangular",17}]]//Timing

Slower

ArcTransitiveQ[g_System`Graph]:=Module[{
auto=AutomorphismGroup[g],
arcs=Join[#,Reverse/@#]&[List@@@EdgeList[g]],
orbs
},
orbs=GroupOrbits[auto,arcs,Function[v,PermutationReplace[v,#2]]/@#1&];
Sort[orbs]=={Sort[arcs]}
]

ArcTransitiveQ[GraphData[{"Triangular",17}]]//Timing

Cubical Graph

auto=AutomorphismGroup[g=GraphData["CubicalGraph"]]

GroupOrder[auto]

arcs=Join[#,Reverse/@#]&[List@@@EdgeList[g]]

GroupOrbits[auto]

GroupOrbits[auto,Range[VertexCount[g]],PermutationReplace[#1,#2]&]

orbs=GroupOrbits[auto,arcs[[{1}]],Function[v,PermutationReplace[v,#2]]/@#1&]

Sort[orbs]=={Sort[arcs]}

FolkmannGraph

auto=AutomorphismGroup[GraphData[g="FolkmanGraph"]]

GroupOrder[auto]

arcs=Join[#,Reverse/@#]&@GraphData[g,"EdgeIndices"]

orbs=GroupOrbits[auto,Range[GraphData[g,"V"]],PermutationReplace[#1,#2]&]

Sort[orbs]=={Sort[arcs]}

Arc transitivity

CubicalGraph

GraphData["CubicalGraph","ArcTransitivity"]

ArcTransitivity[GraphData["CubicalGraph"]]//Timing

Foster468A

GraphData["Foster468A","ArcTransitivity"]

ArcTransitivity[GraphData["Foster468A"]]//Timing

CoxeterGraph

GraphData["CoxeterGraph","ArcTransitivity"]

ArcTransitivity[GraphData["CoxeterGraph"]]//Timing

HigmanSimsGraph

GraphData["HigmanSimsGraph","ArcTransitivity"]

ArcTransitivity[GraphData["HigmanSimsGraph"]]//Timing

Embeddings

<<MathWorld`Graphs`

GraphData["ArcTransitive*"]

3

GraphData["ArcTransitive",3]

4

GraphData["ArcTransitive",4]

5

GraphData["ArcTransitive",5]

6

GraphData["ArcTransitive",6]

7

GraphData["ArcTransitive",7]

8

GraphData["ArcTransitive",8]

9

GraphData["ArcTransitive",9]

10

GraphData["ArcTransitive",10]

11

GraphData["ArcTransitive",11]

12

GraphData["ArcTransitive",12]

13

GraphData["ArcTransitive",13]

14

GraphData["ArcTransitive",14]

15

GraphData["ArcTransitive",15]

16

GraphData["ArcTransitive",16]

17

GraphData["ArcTransitive",17]

18

GraphData["ArcTransitive",18]

19

GraphData["ArcTransitive",19]

20

{"ArcTransitive", {20, 1}} == {"Cycle", 20}

GraphData[{"ArcTransitive", {20, 1}},"StandardName"]

{"ArcTransitive", {20, 2}} == {"Circulant", {20, {1, 9}}}

GraphData[{"ArcTransitive", {20, 2}},"StandardName"]

{"ArcTransitive", {20, 3}} == {"Haar", 525}

GraphData[{"ArcTransitive", {20, 3}},"StandardName"]

{"ArcTransitive", {20, 4}} == {"Circulant", {20, {1, 6, 9}}}

GraphData[{"ArcTransitive", {20, 4}},"StandardName"]

{"ArcTransitive", {20, 5}} == {"EdgeTransitive", {20, 20}}

GraphData[{"ArcTransitive", {20, 5}},"StandardName"]

{"ArcTransitive", {20, 6}} == "DodecahedralGraph"

GraphData[{"ArcTransitive", {20, 6}},"StandardName"]

{"ArcTransitive", {20, 7}} == {"NoncayleyTransitive", {20, 4}}

GraphData[{"ArcTransitive", {20, 7}},"StandardName"]

{"ArcTransitive", {20, 8}} == {"Circulant", {20, {1, 4, 6, 9}}}

GraphData[{"ArcTransitive", {20, 8}},"StandardName"]

{"ArcTransitive", {20, 9}} == {"Circulant", {20, {1, 3, 7, 9}}}

GraphData[{"ArcTransitive", {20, 9}},"StandardName"]

{"ArcTransitive", {20, 10}} == {"CompleteBipartite", {10, 10}}

GraphData[{"ArcTransitive", {20, 10}},"StandardName"]

{"ArcTransitive", {20, 11}} == {"EdgeTransitive", {20, 21}}

GraphData[{"ArcTransitive", {20, 11}},"StandardName"]

{"ArcTransitive", {20, 12}} == "DesarguesGraph"

GraphData[{"ArcTransitive", {20, 12}},"StandardName"]

{"ArcTransitive", {20, 13}} == {"NoncayleyTransitive", {20, 12}}

GraphData[{"ArcTransitive", {20, 13}},"StandardName"]

{"ArcTransitive", {20, 14}} == {"Arrangement", {5, 2}}

GraphData[{"ArcTransitive", {20, 14}},"StandardName"]

{"ArcTransitive", {20, 15}} == {"RookComplement", {4, 5}}

GraphData[{"ArcTransitive", {20, 15}},"StandardName"]

{"ArcTransitive", {20, 16}} == {"CompleteKPartite", {4, 4, 4, 4, 4}}

GraphData[{"ArcTransitive", {20, 16}},"StandardName"]

{"ArcTransitive", {20, 17}} == {"Tetrahedral", 6}

GraphData[{"ArcTransitive", {20, 17}},"StandardName"]

{"ArcTransitive", {20, 18}} == {"Crown", 10}

GraphData[{"ArcTransitive", {20, 18}},"StandardName"]

{"ArcTransitive", {20, 19}} == {"CocktailParty", 10}

GraphData[{"ArcTransitive", {20, 19}},"StandardName"]

{"ArcTransitive", {20, 20}} == {"EdgeTransitive", {20, 38}}

GraphData[{"ArcTransitive", {20, 20}},"StandardName"]

{"ArcTransitive", {20, 21}} == {"CompleteKPartite", {5, 5, 5, 5}}

GraphData[{"ArcTransitive", {20, 21}},"StandardName"]

{"ArcTransitive", {20, 22}} == {"Complete", 20}

GraphData[{"ArcTransitive", {20, 22}},"StandardName"]

21

{"ArcTransitive", {21, 1}} == {"Cycle", 21}

GraphData[{"ArcTransitive", {21, 1}},"StandardName"]

{"ArcTransitive", {21, 2}} == {"Circulant", {21, {1, 8}}}

GraphData[{"ArcTransitive", {21, 2}},"StandardName"]

{"ArcTransitive", {21, 3}} == {"GeneralizedHexagon", {2, 1}}

GraphData[{"ArcTransitive", {21, 3}},"StandardName"]

{"ArcTransitive", {21, 4}} == {"Circulant", {21, {1, 4, 5}}}

GraphData[{"ArcTransitive", {21, 4}},"StandardName"]

{"ArcTransitive", {21, 5}} == {"RookComplement", {3, 7}}

GraphData[{"ArcTransitive", {21, 5}},"StandardName"]

{"ArcTransitive", {21, 6}} == {"CompleteTripartite", {7, 7, 7}}

GraphData[{"ArcTransitive", {21, 6}},"StandardName"]

{"ArcTransitive", {21, 7}}

GraphData[{"ArcTransitive", {21, 7}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive", {21, 7}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive", {21, 7}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"ArcTransitive", {21, 7}},"Planar"]

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

MinimalCrossing

GraphData[{"ArcTransitive", {21, 7}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive", {21, 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[{"ArcTransitive", {21, 7}},"Circulant"]

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

Halin

GraphData[{"ArcTransitive", {21, 7}},"Halin"]

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

Rigid

GraphData[{"ArcTransitive", {21, 7}},"Rigid"]

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

Flexible

GraphData[{"ArcTransitive", {21, 7}},"Flexible"]

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

LCF

GraphData[{"ArcTransitive", {21, 7}},"LCF"]

GraphData[{"ArcTransitive", {21, 7}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive", {21, 7}},"LCFSignature"]

GraphData[{"ArcTransitive", {21, 7}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive", {21, 7}},2,TimeConstraint->120]

LCF compute 10^6

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

Cases[lcf,{_,3}]

First[%]

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive", {21, 7}},"UnitDistance"]

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

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive", {21, 7}},"VertexList"],GraphData[{"ArcTransitive", {21, 7}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive", {21, 7}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"ArcTransitive", {21, 7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"ArcTransitive", {21, 7}},"Polyhedral"]

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

{"ArcTransitive", {21, 8}}

GraphData[{"ArcTransitive", {21, 8}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive", {21, 8}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive", {21, 8}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"ArcTransitive", {21, 8}},"Planar"]

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

MinimalCrossing

GraphData[{"ArcTransitive", {21, 8}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive", {21, 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[{"ArcTransitive", {21, 8}},"Circulant"]

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

Halin

GraphData[{"ArcTransitive", {21, 8}},"Halin"]

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

Rigid

GraphData[{"ArcTransitive", {21, 8}},"Rigid"]

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

Flexible

GraphData[{"ArcTransitive", {21, 8}},"Flexible"]

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

LCF

GraphData[{"ArcTransitive", {21, 8}},"LCF"]

GraphData[{"ArcTransitive", {21, 8}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive", {21, 8}},"LCFSignature"]

GraphData[{"ArcTransitive", {21, 8}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive", {21, 8}},2,TimeConstraint->120]

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"ArcTransitive", {21, 8}}],10^6])[[All,2]]]//Timing

LCF compute 10^7

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive", {21, 8}}],All][[All,All,1]]]//Timing

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

LCFGraph@@@Cases[lcf,{_,3}]//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,{_,_}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,3}]]}])//Timing

Length[gs]

FirstCase[lcf,{_,3}]

LCFGraph@@%

UnitDistance

GraphData[{"ArcTransitive", {21, 8}},"UnitDistance"]

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

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive", {21, 8}},"VertexList"],GraphData[{"ArcTransitive", {21, 8}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive", {21, 8}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"ArcTransitive", {21, 8}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"ArcTransitive", {21, 8}},"Polyhedral"]

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

{"ArcTransitive", {21, 9}} == {"Triangular", 7}

GraphData[{"ArcTransitive", {21, 9}},"StandardName"]

{"ArcTransitive", {21, 10}} == {"Kneser", {7, 2}}

GraphData[{"ArcTransitive", {21, 10}},"StandardName"]

{"ArcTransitive", {21, 11}} == {"Circulant", {21, {1, 6, 8}}}

GraphData[{"ArcTransitive", {21, 11}},"StandardName"]

{"ArcTransitive", {21, 12}} == {"Circulant", {21, {1, 2, 3, 4, 5, 6, 8, 9, 10}}}

GraphData[{"ArcTransitive", {21, 12}},"StandardName"]

{"ArcTransitive", {21, 13}} == {"Complete", 21}

GraphData[{"ArcTransitive", {21, 13}},"StandardName"]

22

GraphData["ArcTransitive",22]

23

GraphData["ArcTransitive",23]

24

{"ArcTransitive", {24, 1}} == {"Cycle", 24}

GraphData[{"ArcTransitive",{24,1}},"StandardName"]

{"ArcTransitive", {24, 2}} == {"Circulant", {24, {1, 11}}}

GraphData[{"ArcTransitive",{24,2}},"StandardName"]

{"ArcTransitive", {24, 3}} == "MoebiusKantorLineGraph"

GraphData[{"ArcTransitive",{24,3}},"StandardName"]

{"ArcTransitive", {24, 4}} == {"CayleyGraph", {24, 2}}

GraphData[{"ArcTransitive",{24,4}},"StandardName"]

{"ArcTransitive", {24, 5}} == {"Circulant", {24, {1, 5}}}

GraphData[{"ArcTransitive",{24,5}},"StandardName"]

{"ArcTransitive", {24, 6}} == {"Circulant", {24, {1, 7}}}

GraphData[{"ArcTransitive",{24,6}},"StandardName"]

{"ArcTransitive", {24, 7}} == "RollingCubeGraph"

GraphData[{"ArcTransitive",{24,7}},"StandardName"]

{"ArcTransitive", {24, 8}} == {"Circulant",{24, {1, 7, 9}}}

GraphData[{"ArcTransitive",{24,8}},"StandardName"]

{"ArcTransitive", {24, 9}}

GraphData[{"ArcTransitive",{24,9}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{24,9}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,9}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{24,9}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,9}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{24,9}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{24,9}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,9}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,9}},"Planar"]

GraphData[{"ArcTransitive",{24,9}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{24,9}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{24,9}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,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[{"ArcTransitive",{24,9}},"Circulant"]

GraphData[{"ArcTransitive",{24,9}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,9}},"Halin"]

GraphData[{"ArcTransitive",{24,9}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,9}},"Rigid"]

GraphData[{"ArcTransitive",{24,9}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,9}},"Flexible"]

GraphData[{"ArcTransitive",{24,9}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,9}},"LCF"]

GraphData[{"ArcTransitive",{24,9}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,9}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,9}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,9}},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{24,9}}],All][[All,All,1]]]//Timing

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

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"ArcTransitive",{24,9}},".m.gz"]])[[All,2]]]//Timing

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{24,9}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,9}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,9}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,9}},"VertexList"],GraphData[{"ArcTransitive",{24,9}},"EdgeList"]]]

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

gs={RotateGraph[,{13,12}],RotateGraph[,{12,22}],RotateGraph[,{15,6}],RotateGraph[,{17,14}]}

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{24,9}},"Matchstick"]

GraphData[{"ArcTransitive",{24,9}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,9}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,9}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,9}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,9}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,9}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 10}}

Names

GraphData[{"ArcTransitive",{24,10}},"StandardName"]

GraphData[{"ArcTransitive",{24,10}},"StandardNames"]

HouseOfGraphs

hogid=GraphData[{"ArcTransitive",{24,10}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

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

Wikidata

GraphData[{"ArcTransitive",{24,10}},"WikidataID"]

GraphData[{"ArcTransitive",{24,10}},"WikidataID","URL"]

Primary

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

All

GraphData[{"ArcTransitive",{24,10}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,10}},"EdgeList"]]

Default embedding

GraphPlot[GraphData[{"ArcTransitive",{24,10}},"Edges"],GraphLayout->"HighDimensionalEmbedding"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,10}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{24,10}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,10}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,10}},"Planar"]

GraphData[{"ArcTransitive",{24,10}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber crossings.uos.de

CrossingNumber[GraphData[{"ArcTransitive",{24,10}}],Method->"WebCompute"]//AbsoluteTiming

DateString[]

MinimalCrossingNumber: "EmbeddingScheme" -> 1

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

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

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

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

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 2

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

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

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

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

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 3

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

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

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

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

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

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

Quit

MinimalCrossing

GraphData[{"ArcTransitive",{24,10}},"CN"]

(gs=GraphData[{"ArcTransitive",{24,10}},"Graph","MinimalCrossing"])//StyleGraphs

GraphCrossingCount/@gs

GraphCrossingDiagram/@gs

MinimalRectilinearCrossing

GraphData[{"ArcTransitive",{24,10}},"RCN"]

GraphData[{"ArcTransitive",{24,10}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"ArcTransitive",{24,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[{"ArcTransitive",{24,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 Tutte

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

(g=MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,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[{"ArcTransitive",{24,10}},"V"]])]
}&/@TutteGraphs;

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

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

LocalCrossingNumberWithEmbeddings=
{1+Max[Length/@DeleteCases[
Drop[AdjacencyList[#],GraphData[{"ArcTransitive",{24,10}},"V"]],
_Integer?(LessEqualThan[GraphData[{"ArcTransitive",{24,10}},"V"]]),
{2}
]],#}&/@TutteGraphs

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

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

Select[SymmetricEmbeddingsWithOrientations[[All,1]],Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{24,10}},"V"]])]==0&]

MinimalCrossing construction Random 1k

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

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,10}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union);//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{24,10}},"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[{"ArcTransitive",{24,10}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

MaxMemoryUsed[]/10^9.GB

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

MinimalCrossing construction Random 20k

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

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,10}}],"CrossingNumber"->cn,RandomSeed->n],{n,20000}]//Union);//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{24,10}},"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[{"ArcTransitive",{24,10}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

MaxMemoryUsed[]/10^9.GB

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

MinimalLocalCrossing

GraphData[{"ArcTransitive",{24,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"ArcTransitive",{24,10}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"ArcTransitive",{24,10}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"ArcTransitive",{24,10}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction 1000

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

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

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,10}}],"CrossingNumber"->cn,RandomSeed->i],{i,1000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

MinimaRectilinearlLocalCrossing construction 20000

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

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

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

Circulant

GraphData[{"ArcTransitive",{24,10}},"Circulant"]

GraphData[{"ArcTransitive",{24,10}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,10}},"Halin"]

GraphData[{"ArcTransitive",{24,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,10}},"Rigid"]

GraphData[{"ArcTransitive",{24,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,10}},"Flexible"]

GraphData[{"ArcTransitive",{24,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,10}},"LCF"]

GraphData[{"ArcTransitive",{24,10}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,10}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,10}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,10}},"Graph","LCF"]//StyleGraphs

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

LCF compute (10^6)

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{24,10}}],All][[All,All,1]]]//Timing

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

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|2}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,2}]]}]

Length[gs]

LCF compute (10^7)

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute ssham_lcf

ReverseSort@Tally[(lcf=Import[FileNameJoin[{$PropertiesDir,"LCFNotations-Nice",GraphNameToFileName[{"ArcTransitive",{24,10}},".m.gz"]}]])[[All,2]]]

gs=NiceLCFGraphs[lcf,6,4]

Length[gs]

nicelcf=LCFNotation/@gs

l2={
{{"ArcTransitive",{24,10}},{0,Missing["External",nicelcf]}}
}

UnitDistance

GraphData[{"ArcTransitive",{24,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,10}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,10}},"Graph","UnitDistance"]//StyleGraphs

Matchstick

GraphData[{"ArcTransitive",{24,10}},"Matchstick"]

GraphData[{"ArcTransitive",{24,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,10}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,10}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,10}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 11}} == "NauruGraph"

GraphData[{"ArcTransitive",{24,11}},"StandardName"]

{"ArcTransitive", {24, 12}}

Names

GraphData[{"ArcTransitive",{24,12}},"StandardName"]

GraphData[{"ArcTransitive",{24,12}},"StandardNames"]

HouseOfGraphs

hogid=GraphData[{"ArcTransitive",{24,12}},"NotationRules","HouseOfGraphs"]

HouseOfGraphsLookup[hogid]

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

Wikidata

GraphData[{"ArcTransitive",{24,12}},"WikidataID"]

GraphData[{"ArcTransitive",{24,12}},"WikidataID","URL"]

Primary

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

All

GraphData[{"ArcTransitive",{24,12}},"Graph","All"]//StyleGraphs

CurvedEdge

GraphData[{"ArcTransitive",{24,12}},"Graph","CurvedEdge"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,12}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{24,12}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,12}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{24,12}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{24,12}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,12}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,12}},"Planar"]

GraphData[{"ArcTransitive",{24,12}},"Graph","Planar"]//StyleGraphs

MinimalCrossingNumber crossings.uos.de

CrossingNumber[GraphData[{"ArcTransitive",{24,12}}],Method->"WebCompute"]//AbsoluteTiming

DateString[]

MinimalCrossingNumber: "EmbeddingScheme" -> 1

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,12}}],"EmbeddingScheme"->1,TimeConstraint->1])//AbsoluteTiming

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

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

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

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 2

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

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

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

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

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 3

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

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

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

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

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

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

Quit

MinimalCrossing

GraphData[{"ArcTransitive",{24,12}},"CN"]

(gs=GraphData[{"ArcTransitive",{24,12}},"Graph","MinimalCrossing"])//StyleGraphs

GraphCrossingCount/@gs

GraphCrossingDiagram/@gs

MinimalRectilinearCrossing

GraphData[{"ArcTransitive",{24,12}},"RCN"]

GraphData[{"ArcTransitive",{24,12}},"Graph","MinimalRectilinearCrossing"]//StyleGraphs

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"ArcTransitive",{24,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[{"ArcTransitive",{24,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 Tutte

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

(g=MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,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[{"ArcTransitive",{24,12}},"V"]])]
}&/@TutteGraphs;

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

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

LocalCrossingNumberWithEmbeddings=
{1+Max[Length/@DeleteCases[
Drop[AdjacencyList[#],GraphData[{"ArcTransitive",{24,12}},"V"]],
_Integer?(LessEqualThan[GraphData[{"ArcTransitive",{24,12}},"V"]]),
{2}
]],#}&/@TutteGraphs

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

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

Select[SymmetricEmbeddingsWithOrientations[[All,1]],Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{24,12}},"V"]])]==0&]

MinimalCrossing construction Random 1k

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

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,12}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union);//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{24,12}},"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[{"ArcTransitive",{24,12}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

MaxMemoryUsed[]/10^9.GB

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

MinimalCrossing construction Random 20k

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

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,12}}],"CrossingNumber"->cn,RandomSeed->n],{n,20000}]//Union);//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{24,12}},"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[{"ArcTransitive",{24,12}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

MaxMemoryUsed[]/10^9.GB

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

MinimalLocalCrossing

GraphData[{"ArcTransitive",{24,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"ArcTransitive",{24,12}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"ArcTransitive",{24,12}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"ArcTransitive",{24,12}},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction 1000

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

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

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,12}}],"CrossingNumber"->cn,RandomSeed->i],{i,1000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

MinimaRectilinearlLocalCrossing construction 20000

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

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

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

Circulant

GraphData[{"ArcTransitive",{24,12}},"Circulant"]

GraphData[{"ArcTransitive",{24,12}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,12}},"Halin"]

GraphData[{"ArcTransitive",{24,12}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,12}},"Rigid"]

GraphData[{"ArcTransitive",{24,12}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,12}},"Flexible"]

GraphData[{"ArcTransitive",{24,12}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,12}},"LCF"]

GraphData[{"ArcTransitive",{24,12}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,12}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,12}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,12}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{24,12}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@DeleteCases[lcf,{_,1|2}]//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|2}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,2}]]}])//Timing

Length[gs]

LCF compute 10^7

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

Cases[lcf,{_,6}]

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

(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|2|3|4}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,3|4}]]}])//Timing

Length[gs]

LCF compute ssham_lcf

ReverseSort@Tally[(lcf=Import[FileNameJoin[{$PropertiesDir,"LCFNotations-Nice",GraphNameToFileName[{"ArcTransitive",{24,12}},".m.gz"]}]])[[All,2]]]

Length[gs=NiceLCFGraphs[lcf,3,2]]

Length[gs=NiceLCFGraphs[lcf,3]]

Length[gs=NiceLCFGraphs[lcf,5,4]]

gs

nicelcf=LCFNotation/@gs

l2={
{{"ArcTransitive",{24,12}},{0,Missing["External",nicelcf]}}
}

UnitDistance

GraphData[{"ArcTransitive",{24,12}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,12}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,12}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,12}},"VertexList"],GraphData[{"ArcTransitive",{24,12}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{24,12}},"Matchstick"]

GraphData[{"ArcTransitive",{24,12}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,12}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,12}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,12}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,12}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,12}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 13}} == {"Circulant", {24, {1, 5, 7, 11}}}

GraphData[{"ArcTransitive",{24,13}},"StandardName"]

{"ArcTransitive", {24, 14}}

GraphData[{"ArcTransitive",{24,14}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{24,14}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,14}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{24,14}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,14}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{24,14}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,14}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,14}},"Planar"]

GraphData[{"ArcTransitive",{24,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{24,14}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{24,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,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[{"ArcTransitive",{24,14}},"Circulant"]

GraphData[{"ArcTransitive",{24,14}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,14}},"Halin"]

GraphData[{"ArcTransitive",{24,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,14}},"Rigid"]

GraphData[{"ArcTransitive",{24,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,14}},"Flexible"]

GraphData[{"ArcTransitive",{24,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,14}},"LCF"]

GraphData[{"ArcTransitive",{24,14}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,14}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,14}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,14}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{24,14}},2,TimeConstraint->120]

ComputeRandomLCFNotation[{"ArcTransitive",{24,14}},3,TimeConstraint->120]

g=LCFGraph@@{{{-12,-11,5,6,9,10},{-9,-2,2,3,5,10},{-10,-8,-6,3,8,10},{-12,-10,-6,-5,-2,2},{-12,-10,-8,-3,6,8},{-6,-5,-3,-2,6,11},{-8,-6,-5,5,8,9},{-12,-9,-8,2,6,8}},3}

BilateralLCFEmbedding@g

RecognizeGraph@g

LCF compute 10^6

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{24,14}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{24,14}}],10^6])[[All,2]]]//Timing

LCF compute 10^7

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

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}]]}]

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{24,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,14}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,14}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,14}},"VertexList"],GraphData[{"ArcTransitive",{24,14}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{24,14}},"Matchstick"]

GraphData[{"ArcTransitive",{24,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,14}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,14}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,14}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 15}}

GraphData[{"ArcTransitive",{24,15}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{24,15}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,15}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{24,15}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,15}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{24,15}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{24,15}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,15}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,15}},"Planar"]

GraphData[{"ArcTransitive",{24,15}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{24,15}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{24,15}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,15}}],TimeConstraint->1])//AbsoluteTiming

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,15}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{24,15}},"Circulant"]

GraphData[{"ArcTransitive",{24,15}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,15}},"Halin"]

GraphData[{"ArcTransitive",{24,15}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,15}},"Rigid"]

GraphData[{"ArcTransitive",{24,15}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,15}},"Flexible"]

GraphData[{"ArcTransitive",{24,15}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,15}},"LCF"]

GraphData[{"ArcTransitive",{24,15}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,15}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,15}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,15}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{24,15}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@DeleteCases[lcf,{_,1|2}]//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|2}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,2}]]}])//Timing

Length[gs]

LCF compute 10^7

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

FirstCase[lcf,{_,8}]

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{24,15}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,15}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,15}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,15}},"VertexList"],GraphData[{"ArcTransitive",{24,15}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{24,15}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{24,15}},"Matchstick"]

GraphData[{"ArcTransitive",{24,15}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,15}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,15}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,15}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,15}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,15}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 16}} == "TwentyFourCellGraph"

GraphData[{"ArcTransitive",{24,16}},"StandardName"]

{"ArcTransitive", {24, 17}}

GraphData[{"ArcTransitive",{24,17}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{24,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{24,17}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,17}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{24,17}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{24,17}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{24,17}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,17}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,17}},"Planar"]

GraphData[{"ArcTransitive",{24,17}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{24,17}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{24,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,17}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,17}}],TimeConstraint->10])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,17}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{24,17}},"Circulant"]

GraphData[{"ArcTransitive",{24,17}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,17}},"Halin"]

GraphData[{"ArcTransitive",{24,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,17}},"Rigid"]

GraphData[{"ArcTransitive",{24,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,17}},"Flexible"]

GraphData[{"ArcTransitive",{24,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,17}},"LCF"]

GraphData[{"ArcTransitive",{24,17}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,17}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,17}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,17}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{24,17}},2,TimeConstraint->120]

LCF compute 10^5

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

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,{_,_}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,2}]]}])//Timing

Length[gs]

LCF compute 10^7

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

Cases[lcf,{_,4}]

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{24,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,17}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,17}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,17}},"VertexList"],GraphData[{"ArcTransitive",{24,17}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{24,17}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{24,17}},"Matchstick"]

GraphData[{"ArcTransitive",{24,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,17}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,17}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,17}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 18}}

GraphData[{"ArcTransitive",{24,18}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{24,18}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{24,18}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,18}},"EdgeList"]]

Default embedding

GraphPlot[GraphData[{"ArcTransitive",{24,18}},"Edges"],GraphLayout->"HighDimensionalEmbedding"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,18}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{24,18}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,18}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,18}},"Planar"]

GraphData[{"ArcTransitive",{24,18}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{24,18}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{24,18}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,18}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,18}}],TimeConstraint->10])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,18}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{24,18}},"Circulant"]

GraphData[{"ArcTransitive",{24,18}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,18}},"Halin"]

GraphData[{"ArcTransitive",{24,18}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,18}},"Rigid"]

GraphData[{"ArcTransitive",{24,18}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,18}},"Flexible"]

GraphData[{"ArcTransitive",{24,18}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,18}},"LCF"]

GraphData[{"ArcTransitive",{24,18}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,18}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,18}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,18}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{24,18}},2,TimeConstraint->120]

LCF compute 10^6

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{24,18}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{24,18}}],10^6])[[All,2]]]//Timing

LCFGraph@@@Cases[lcf,{_,2}]//StyleGraphs

LCFNotation/@%

LCF compute 10^7

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

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}]]}]

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{24,18}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,18}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,18}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,18}},"VertexList"],GraphData[{"ArcTransitive",{24,18}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{24,18}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{24,18}},"Matchstick"]

GraphData[{"ArcTransitive",{24,18}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,18}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,18}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,18}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,18}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,18}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 19}} == {"ZeroTwoBipartite", {5, 2}}

GraphData[{"ArcTransitive",{24,19}},"StandardName"]

{"ArcTransitive", {24, 20}} == {"CompleteBipartite", {12, 12}}

GraphData[{"ArcTransitive",{24,20}},"StandardName"]

{"ArcTransitive", {24, 21}} == {"Circulant", {24, {1, 2, 5, 7, 10, 11}}}

GraphData[{"ArcTransitive",{24,21}},"StandardName"]

{"ArcTransitive", {24, 22}} == {"RookComplement", {3, 8}}

GraphData[{"ArcTransitive",{24,22}},"StandardName"]

{"ArcTransitive", {24, 23}} == "KleinGraph24"

GraphData[{"ArcTransitive",{24,23}},"StandardName"]

{"ArcTransitive", {24, 24}} == {"CompleteTripartite", {8, 8, 8}}

GraphData[{"ArcTransitive",{24,24}},"StandardName"]

{"ArcTransitive", {24, 25}} == {"Circulant", {24, {1, 2, 3, 5, 6, 7, 9, 10, 11}}}

GraphData[{"ArcTransitive",{24,25}},"StandardName"]

{"ArcTransitive", {24, 26}}

GraphData[{"ArcTransitive",{24,26}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{24,26}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{24,26}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,26}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{24,26}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,26}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{24,26}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,26}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,26}},"Planar"]

GraphData[{"ArcTransitive",{24,26}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{24,26}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{24,26}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,26}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,26}}],TimeConstraint->10])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,26}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{24,26}},"Circulant"]

GraphData[{"ArcTransitive",{24,26}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,26}},"Halin"]

GraphData[{"ArcTransitive",{24,26}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,26}},"Rigid"]

GraphData[{"ArcTransitive",{24,26}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,26}},"Flexible"]

GraphData[{"ArcTransitive",{24,26}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,26}},"LCF"]

GraphData[{"ArcTransitive",{24,26}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,26}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,26}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,26}},"Graph","LCF"]//StyleGraphs

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

LCFNotation/@%

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{24,26}},2,TimeConstraint->120]

LCF compute 10^6

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{24,26}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{24,26}}],10^6])[[All,2]]]//Timing

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{24,26}}],All][[All,All,1]]]//Timing

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

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}]]}]

lcf=FirstCase[lcf,{_,4}]

g=LCFGraph[Sequence@@lcf,11]

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{24,26}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,26}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,26}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,26}},"VertexList"],GraphData[{"ArcTransitive",{24,26}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{24,26}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{24,26}},"Matchstick"]

GraphData[{"ArcTransitive",{24,26}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,26}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,26}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,26}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,26}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,26}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 27}}

GraphData[{"ArcTransitive",{24,27}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{24,27}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{24,27}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{24,27}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{24,27}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{24,27}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{24,27}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{24,27}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{24,27}},"Planar"]

GraphData[{"ArcTransitive",{24,27}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{24,27}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{24,27}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,27}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{24,27}}],TimeConstraint->10])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{24,27}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{24,27}},"Circulant"]

GraphData[{"ArcTransitive",{24,27}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{24,27}},"Halin"]

GraphData[{"ArcTransitive",{24,27}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{24,27}},"Rigid"]

GraphData[{"ArcTransitive",{24,27}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{24,27}},"Flexible"]

GraphData[{"ArcTransitive",{24,27}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{24,27}},"LCF"]

GraphData[{"ArcTransitive",{24,27}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{24,27}},"LCFSignature"]

GraphData[{"ArcTransitive",{24,27}},"LCFNotations"]

GraphData[{"ArcTransitive",{24,27}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{24,27}},2,TimeConstraint->120]

LCF compute 10^5

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

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{24,27}}],10^6])[[All,2]]]//Timing

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{24,27}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{24,27}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{24,27}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{24,27}},"VertexList"],GraphData[{"ArcTransitive",{24,27}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{24,27}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{24,27}},"Matchstick"]

GraphData[{"ArcTransitive",{24,27}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{24,27}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{24,27}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{24,27}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{24,27}},"Polyhedral"]

GraphData[{"ArcTransitive",{24,27}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {24, 28}} == {"Transposition", 4}

GraphData[{"ArcTransitive",{24,28}},"StandardName"]

{"ArcTransitive", {24, 29}} == {"Circulant", {24, {1, 2, 3, 4, 5, 7, 8, 9, 10, 11}}}

GraphData[{"ArcTransitive",{24,29}},"StandardName"]

{"ArcTransitive", {24, 30}} == {"Circulant", {24, {1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12}}}

GraphData[{"ArcTransitive",{24,30}},"StandardName"]

{"ArcTransitive", {24, 31}} == {"RookComplement", {4, 6}}

GraphData[{"ArcTransitive",{24,31}},"StandardName"]

{"ArcTransitive", {24, 32}} == {"CocktailParty", 12}

GraphData[{"ArcTransitive",{24,32}},"StandardName"]

{"ArcTransitive", {24, 33}} == {"Crown", 12}

GraphData[{"ArcTransitive",{24,33}},"StandardName"]

{"ArcTransitive", {24, 34}} == {"Complete", 24}

GraphData[{"ArcTransitive",{24,34}},"StandardName"]

25

{"ArcTransitive", {25, 1}} == {"Cycle", 25}

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

{"ArcTransitive", {25, 2}} == {"TorusGrid", {5, 5}}

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

{"ArcTransitive", {25, 3}}

Names

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{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[{"ArcTransitive",{25,3}},"Circulant"]

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

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

LCF compute all batch

LCF compute all

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

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

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"ArcTransitive",{25,3}},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

Tally[%[[All,-1]]]

lcf=GraphData[{"ArcTransitive",{25,3}},"LCFNotations"]/.Missing["TooLarge",l_]:>l

LCFGraph@@@lcf//StyleGraphs

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

BilateralGraphEmbeddingQ/@gs

Length[gs]

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"ArcTransitive", {25, 4}}

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{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[{"ArcTransitive",{25,4}},"Circulant"]

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

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

lcf={{{-12,-8,-6,-3,6,8},{-8,-6,-3,3,6,8},{-8,-6,3,6,8,12},{-8,-6,-4,3,8,12},{-12,-8,-3,4,6,8}},5};

g=BilateralLCFEmbedding[lcf]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

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

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

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

UnitDistance by refinement

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

Found by Eric Weisstein, Jan. 19, 2023

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

RotateGraph[ContractCoincidentVertices[],-Pi/10]

RecognizeGraph@%

GraphPlot@

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"ArcTransitive", {25, 5}} == {"Circulant", {25, {1, 7}}}

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

{"ArcTransitive", {25, 6}} == {"Circulant", {25, {1, 4, 6, 9, 11}}}

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

{"ArcTransitive", {25, 7}} == {"Rook", {5, 5}}

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

{"ArcTransitive", {25, 8}} == {"Paley", 25}

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

{"ArcTransitive", {25, 9}} == {"RookComplement", {5, 5}}

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

{"ArcTransitive", {25, 10}} == {"Circulant", {25, {1, 2, 3, 4, 6, 7, 8, 9, 11, 12}}}

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

{"ArcTransitive", {25, 11}} == {"Complete", 25}

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

26

GraphData["ArcTransitive",26]

Cases[%,{"ArcTransitive",_}]

27

GraphData["ArcTransitive",27]

Cases[%,{"ArcTransitive",_}]

{"ArcTransitive", {27, 1}} == {"Cycle", 27}

GraphData[{"ArcTransitive",{27,1}},"StandardName"]

{"ArcTransitive", {27, 2}}

GraphData[{"ArcTransitive",{27,2}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,2}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,2}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"ArcTransitive",{27,2}},"Planar"]

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

MinimalCrossing

GraphData[{"ArcTransitive",{27,2}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,2}},"Circulant"]

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

Halin

GraphData[{"ArcTransitive",{27,2}},"Halin"]

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

Rigid

GraphData[{"ArcTransitive",{27,2}},"Rigid"]

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

Flexible

GraphData[{"ArcTransitive",{27,2}},"Flexible"]

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

LCF

GraphData[{"ArcTransitive",{27,2}},"LCF"]

GraphData[{"ArcTransitive",{27,2}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,2}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,2}},"LCFNotations"]

%/.Missing[_,l_]:>Tally[l[[All,2]]]

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

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,2}},2,TimeConstraint->120]

LCF compute all

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

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{27,2}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,2}},"VertexList"],GraphData[{"ArcTransitive",{27,2}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{27,2}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"ArcTransitive",{27,2}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"ArcTransitive",{27,2}},"Polyhedral"]

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

{"ArcTransitive", {27, 3}} == "PappusLineGraph"

GraphData[{"ArcTransitive",{27,3}},"StandardName"]

{"ArcTransitive", {27, 4}} == {"Circulant", {27, {1, 8, 10}}}

GraphData[{"ArcTransitive",{27,4}},"StandardName"]

{"ArcTransitive", {27, 5}}

GraphData[{"ArcTransitive",{27,5}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,5}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,5}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"ArcTransitive",{27,5}},"Planar"]

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

MinimalCrossing

GraphData[{"ArcTransitive",{27,5}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,5}},"Circulant"]

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

Halin

GraphData[{"ArcTransitive",{27,5}},"Halin"]

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

Rigid

GraphData[{"ArcTransitive",{27,5}},"Rigid"]

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

Flexible

GraphData[{"ArcTransitive",{27,5}},"Flexible"]

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

LCF

GraphData[{"ArcTransitive",{27,5}},"LCF"]

GraphData[{"ArcTransitive",{27,5}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,5}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,5}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,5}},2,TimeConstraint->120]

LCF compute 10^5

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

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]

LCF compute 10^7

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

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCFNotation/@gs

UnitDistance

GraphData[{"ArcTransitive",{27,5}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,5}},"VertexList"],GraphData[{"ArcTransitive",{27,5}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{27,5}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"ArcTransitive",{27,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"ArcTransitive",{27,5}},"Polyhedral"]

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

{"ArcTransitive", {27, 6}} == {"Hamming", {3, 3}}

GraphData[{"ArcTransitive",{27,6}},"StandardName"]

{"ArcTransitive", {27, 7}}

Names

GraphData[{"ArcTransitive",{27,7}},"StandardName"]

GraphData[{"ArcTransitive",{27,7}},"StandardNames"]

HouseOfGraphs

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

HouseOfGraphsLookup[hogid]

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

Wikidata

GraphData[{"ArcTransitive",{27,7}},"WikidataID"]

GraphData[{"ArcTransitive",{27,7}},"WikidataID","URL"]

Primary

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

All

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

CurvedEdge

GraphData[{"ArcTransitive",{27,7}},"Graph","CurvedEdge"]//StyleGraphs

Inexact

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

Degenerate

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

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{27,7}},"Graph","Degenerate"]//Column

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,7}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,7}},"Edges"]

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

RecognizeGraph[g]

GeneralizedPetersen

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

IGraph

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

CompleteKPartite

GraphData[{"ArcTransitive",{27,7}},"Graph","CompleteKPartite"]//StyleGraphs

Bipartite

GraphData[{"ArcTransitive",{27,7}},"Bipartite"]

GraphData[{"ArcTransitive",{27,7}},"Graph","Bipartite"]//StyleGraphs

Bilateral

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

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

Circular

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

Circular construction All

GraphData[{"ArcTransitive",{27,7}},"Hamiltonian"]

GraphData[{"ArcTransitive",{27,7}},"LCF"]

GraphData[{"ArcTransitive",{27,7}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,7}},"HamiltonianCycles"]

Planar

GraphData[{"ArcTransitive",{27,7}},"Planar"]

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

MinimalCrossingNumber crossings.uos.de [failed]

CrossingNumber[GraphData[{"ArcTransitive",{27,7}}],Method->"WebCompute"]//AbsoluteTiming

DateString[]

MinimalCrossingNumber: "EmbeddingScheme" -> 1

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

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

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

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

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 2

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

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

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

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

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

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

MinimalCrossingNumber: "EmbeddingScheme" -> 3

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

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

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

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

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

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

MinimalCrossing

GraphData[{"ArcTransitive",{27,7}},"CN"]

(gs=GraphData[{"ArcTransitive",{27,7}},"Graph","MinimalCrossing"])//StyleGraphs

GraphCrossingCount/@gs

GraphCrossingDiagram/@gs

MinimalRectilinearCrossing

GraphData[{"ArcTransitive",{27,7}},"RCN"]

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

MinimalRectilinearCrossing construction order X [minimum RCN == ]

Length[gs=FindMinimalRectilinearCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,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 Tutte

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

(g=MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,7}},"V"]])]
}&/@TutteGraphs;

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

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

LocalCrossingNumberWithEmbeddings=
{1+Max[Length/@DeleteCases[
Drop[AdjacencyList[#],GraphData[{"ArcTransitive",{27,7}},"V"]],
_Integer?(LessEqualThan[GraphData[{"ArcTransitive",{27,7}},"V"]]),
{2}
]],#}&/@TutteGraphs

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

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

Select[SymmetricEmbeddingsWithOrientations[[All,1]],Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{27,7}},"V"]])]==0&]

MinimalCrossing construction Random 1k [XXX s]

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

Length[diagrams=DistinctMinimalCrossingDiagramData[
GraphData[{"ArcTransitive",{27,7}}],
1000,
"CrossingNumber"->cn,
EdgeShapeFunction->"BezierEdge"
]]//AbsoluteTiming

No crossing points on the boundary:

Length[diagrams0=Lookup[Select[diagrams,MinimalCrossingOuterCrossingCount[#]==0&],"Graph",{}]//Timing

One crossing point on the boundary:

Length[diagrams1=Lookup[Select[diagrams,MinimalCrossingOuterCrossingCount[#]==1&],"Graph",{}]]//Timing

graphs=#["Graph"]&/@diagrams;

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[#]
}&/@graphs;//AbsoluteTiming

MaxMemoryUsed[]/10^9.GB

Symmetric embeddings:

Length[SymmetricMinimalEmbeddingData=DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]
]//AbsoluteTiming

SymmetricMinimalEmbeddingData

SymmetricMinimalEmbeddingGraphs=SymmetricMinimalEmbeddingData[[All,1]]

GraphCrossingCount/@SymmetricMinimalEmbeddingGraphs

GraphCrossingDiagram/@SymmetricMinimalEmbeddingGraphs

MinimalCrossing construction Random 5k [XXX s]

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

Length[diagrams=DistinctMinimalCrossingDiagramData[
GraphData[{"ArcTransitive",{27,7}}],
5000,
"CrossingNumber"->cn,
EdgeShapeFunction->"BezierEdge"
]]//AbsoluteTiming

No crossing points on the boundary:

Length[diagrams0=Lookup[Select[diagrams,MinimalCrossingOuterCrossingCount[#]==0&],"Graph",{}]]//Timing

One crossing point on the boundary:

Length[diagrams1=Lookup[Select[diagrams,MinimalCrossingOuterCrossingCount[#]==1&],"Graph",{}]]//Timing

graphs=#["Graph"]&/@diagrams;

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[#]
}&/@graphs;//AbsoluteTiming

MaxMemoryUsed[]/10^9.GB

Symmetric embeddings:

Length[SymmetricMinimalEmbeddingData=DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]
]//AbsoluteTiming

SymmetricMinimalEmbeddingData

SymmetricMinimalEmbeddingGraphs=SymmetricMinimalEmbeddingData[[All,1]]

GraphCrossingCount/@SymmetricMinimalEmbeddingGraphs

GraphCrossingDiagram/@SymmetricMinimalEmbeddingGraphs

MinimalCrossing construction Random 20k [XXX s]

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

Length[diagrams=DistinctMinimalCrossingDiagramData[
GraphData[{"ArcTransitive",{27,7}}],
20*^3,
"CrossingNumber"->cn,
EdgeShapeFunction->"BezierEdge"
]]//AbsoluteTiming

No crossing points on the boundary:

Length[diagrams0=Lookup[Select[diagrams,MinimalCrossingOuterCrossingCount[#]==0&],"Graph",{}]]//Timing

One crossing point on the boundary:

Length[diagrams1=Lookup[Select[diagrams,MinimalCrossingOuterCrossingCount[#]==1&],"Graph",{}]]//Timing

graphs=#["Graph"]&/@diagrams;

Symmetric embeddings:

RandomGraphsWithSymmetryGroups={
#,
GraphSymmetryGroup[#]
}&/@graphs;//AbsoluteTiming

MaxMemoryUsed[]/10^9.GB

Symmetric embeddings:

Length[SymmetricMinimalEmbeddingData=DeleteCases[
RandomGraphsWithSymmetryGroups,
{_,TransformationGroup[{}]}
]
]//AbsoluteTiming

SymmetricMinimalEmbeddingData

SymmetricMinimalEmbeddingGraphs=SymmetricMinimalEmbeddingData[[All,1]]

GraphCrossingCount/@SymmetricMinimalEmbeddingGraphs

GraphCrossingDiagram/@SymmetricMinimalEmbeddingGraphs

MinimalCrossing construction Random 1k [old]

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

(RandomGraphs=Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,7}}],"CrossingNumber"->cn,RandomSeed->n],{n,1000}]//Union);//Timing

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{27,7}},"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[{"ArcTransitive",{27,7}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

MaxMemoryUsed[]/10^9.GB

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

MinimalCrossing construction Random 20k [old]

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

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

RandomGraphsWithOuterCrossingPointCounts={
#,
Count[OuterFace[#],_?(GreaterThan[GraphData[{"ArcTransitive",{27,7}},"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[{"ArcTransitive",{27,7}},"V"]],Table[False,cn]],
SameTest->Equal
]
}&/@RandomGraphs;

MaxMemoryUsed[]/10^9.GB

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

MinimalLocalCrossing

GraphData[{"ArcTransitive",{27,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimalRectilinearLocalCrossing

GraphData[{"ArcTransitive",{27,7}},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

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

MinimaRectilinearlLocalCrossing construction 1000

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

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

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

MinimaRectilinearlLocalCrossing construction 20000

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

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

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

Circulant

GraphData[{"ArcTransitive",{27,7}},"Circulant"]

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

Circulant construction

GraphData[{"ArcTransitive",{27,7}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"ArcTransitive",{27,7}}]])//AbsoluteTiming

CirculantGraph1@@@ci

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

CirculantGraph1@@@%

Halin

GraphData[{"ArcTransitive",{27,7}},"Halin"]

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

Rigid

GraphData[{"ArcTransitive",{27,7}},"Rigid"]

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

Flexible

GraphData[{"ArcTransitive",{27,7}},"Flexible"]

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

LCF

GraphData[{"ArcTransitive",{27,7}},"LCF"]

GraphData[{"ArcTransitive",{27,7}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,7}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,7}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,7}},2,TimeConstraint->120]

LCF compute 10^5

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

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]

LCF compute 10^7

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

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

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|3}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,3}]]}])//Timing

Length[gs]

LCFNotation/@gs

LCF compute ssham_lcf

ReverseSort@Tally[(lcf=Import[FileNameJoin[{$GraphDataDirectory,"Properties","LCFNotations-Nice",GraphNameToFileName[{"ArcTransitive",{27,7}},".m.gz"]}]])[[All,2]]]

gs=NiceLCFGraphs[lcf,4,3]

Length[gs]

nicelcf=LCFNotation/@gs

l2={
{{"ArcTransitive",{27,7}},{0,Missing["External",nicelcf]}}
}

PropertyReplace[l2,"LCFNotations"]

RenameGraphFiles[]

Length[BilateralOrder1LCF=Get[FileNameJoin[{"/","Volumes","eww","mma","Graphs","Properties","LCFNotations-Nice",GraphNameToFileName[{"ArcTransitive",{27,7}},"_bilateral-order-1-reserve.log"]}]]]

BilateralLCFGraph@@@BilateralOrder1LCF//Length//Timing

BilateralLCFGraph@@@Take[BilateralOrder1LCF,10]

Length[bilat=SelectBilateralLCFs[BilateralOrder1LCF,"ProgressEvery"->500,Debug->True]]//Timing

UnitDistance

GraphData[{"ArcTransitive",{27,7}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,7}},"VertexList"],GraphData[{"ArcTransitive",{27,7}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{27,7}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"ArcTransitive",{27,7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"ArcTransitive",{27,7}},"Polyhedral"]

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

{"ArcTransitive", {27, 8}} == "GrayConfigurationMengerDual"

GraphData[{"ArcTransitive",{27,8}},"StandardName"]

{"ArcTransitive", {27, 9}}

GraphData[{"ArcTransitive",{27,9}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{27,9}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,9}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,9}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{27,9}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{27,9}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{27,9}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{27,9}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{27,9}},"Planar"]

GraphData[{"ArcTransitive",{27,9}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{27,9}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{27,9}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,9}},"Circulant"]

GraphData[{"ArcTransitive",{27,9}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{27,9}},"Halin"]

GraphData[{"ArcTransitive",{27,9}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{27,9}},"Rigid"]

GraphData[{"ArcTransitive",{27,9}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{27,9}},"Flexible"]

GraphData[{"ArcTransitive",{27,9}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{27,9}},"LCF"]

GraphData[{"ArcTransitive",{27,9}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,9}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,9}},"LCFNotations"]

GraphData[{"ArcTransitive",{27,9}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,9}},2,TimeConstraint->120]

LCF compute 10^5

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

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]

LCF compute 10^7

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{27,9}}],All][[All,All,1]]]//Timing

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

Cases[lcf,{_,3}]

LCFGraph@@@Cases[lcf,{_,3}]//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[{"ArcTransitive",{27,9}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{27,9}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{27,9}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,9}},"VertexList"],GraphData[{"ArcTransitive",{27,9}},"EdgeList"]]]

UnitDistanceGraphEmbeddingQ[%]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{27,9}},"Matchstick"]

GraphData[{"ArcTransitive",{27,9}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{27,9}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{27,9}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{27,9}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{27,9}},"Polyhedral"]

GraphData[{"ArcTransitive",{27,9}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {27, 10}}

GraphData[{"ArcTransitive",{27,10}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{27,10}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,10}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,10}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{27,10}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{27,10}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{27,10}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{27,10}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{27,10}},"Planar"]

GraphData[{"ArcTransitive",{27,10}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{27,10}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{27,10}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,10}},"Circulant"]

GraphData[{"ArcTransitive",{27,10}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{27,10}},"Halin"]

GraphData[{"ArcTransitive",{27,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{27,10}},"Rigid"]

GraphData[{"ArcTransitive",{27,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{27,10}},"Flexible"]

GraphData[{"ArcTransitive",{27,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{27,10}},"LCF"]

GraphData[{"ArcTransitive",{27,10}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,10}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,10}},"LCFNotations"]

GraphData[{"ArcTransitive",{27,10}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,10}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{27,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{27,10}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{27,10}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,10}},"VertexList"],GraphData[{"ArcTransitive",{27,10}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{27,10}},"Matchstick"]

GraphData[{"ArcTransitive",{27,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{27,10}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{27,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{27,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{27,10}},"Polyhedral"]

GraphData[{"ArcTransitive",{27,10}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {27, 11}}

GraphData[{"ArcTransitive",{27,11}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{27,11}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,11}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,11}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{27,11}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{27,11}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{27,11}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{27,11}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{27,11}},"Planar"]

GraphData[{"ArcTransitive",{27,11}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{27,11}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{27,11}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,11}},"Circulant"]

GraphData[{"ArcTransitive",{27,11}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{27,11}},"Halin"]

GraphData[{"ArcTransitive",{27,11}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{27,11}},"Rigid"]

GraphData[{"ArcTransitive",{27,11}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{27,11}},"Flexible"]

GraphData[{"ArcTransitive",{27,11}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{27,11}},"LCF"]

GraphData[{"ArcTransitive",{27,11}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,11}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,11}},"LCFNotations"]

GraphData[{"ArcTransitive",{27,11}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,11}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{27,11}}],All][[All,All,1]]]//Timing

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,11}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{27,11}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{27,11}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,11}},"VertexList"],GraphData[{"ArcTransitive",{27,11}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{27,11}},"Matchstick"]

GraphData[{"ArcTransitive",{27,11}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{27,11}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{27,11}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{27,11}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{27,11}},"Polyhedral"]

GraphData[{"ArcTransitive",{27,11}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {27, 12}}

GraphData[{"ArcTransitive",{27,12}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{27,12}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,12}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,12}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{27,12}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{27,12}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{27,12}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{27,12}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{27,12}},"Planar"]

GraphData[{"ArcTransitive",{27,12}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{27,12}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{27,12}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,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[{"ArcTransitive",{27,12}},"Circulant"]

GraphData[{"ArcTransitive",{27,12}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{27,12}},"Halin"]

GraphData[{"ArcTransitive",{27,12}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{27,12}},"Rigid"]

GraphData[{"ArcTransitive",{27,12}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{27,12}},"Flexible"]

GraphData[{"ArcTransitive",{27,12}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{27,12}},"LCF"]

GraphData[{"ArcTransitive",{27,12}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,12}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,12}},"LCFNotations"]

GraphData[{"ArcTransitive",{27,12}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,12}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{27,12}}],All][[All,All,1]]]//Timing

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{27,12}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{27,12}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{27,12}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,12}},"VertexList"],GraphData[{"ArcTransitive",{27,12}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{27,12}},"Matchstick"]

GraphData[{"ArcTransitive",{27,12}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{27,12}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{27,12}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{27,12}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{27,12}},"Polyhedral"]

GraphData[{"ArcTransitive",{27,12}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {27, 13}} == {"GeneralizedQuadrangleMinusSpread", {{2, 4}, 2}}

GraphData[{"ArcTransitive",{27,13}},"StandardName"]

{"ArcTransitive", {27, 14}} == "SchlaefliGraph"

GraphData[{"ArcTransitive",{27,14}},"StandardName"]

{"ArcTransitive", {27, 15}} == {"RookComplement", {3, 9}}

GraphData[{"ArcTransitive",{27,15}},"StandardName"]

{"ArcTransitive", {27, 16}} == {"CompleteTripartite", {9, 9, 9}}

GraphData[{"ArcTransitive",{27,16}},"StandardName"]

{"ArcTransitive", {27, 17}}

GraphData[{"ArcTransitive",{27,17}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{27,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{27,17}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{27,17}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{27,17}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{27,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{27,17}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{27,17}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{27,17}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{27,17}},"Planar"]

GraphData[{"ArcTransitive",{27,17}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{27,17}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{27,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{27,17}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{27,17}}],TimeConstraint->10])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{27,17}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{27,17}},"Circulant"]

GraphData[{"ArcTransitive",{27,17}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{27,17}},"Halin"]

GraphData[{"ArcTransitive",{27,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{27,17}},"Rigid"]

GraphData[{"ArcTransitive",{27,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{27,17}},"Flexible"]

GraphData[{"ArcTransitive",{27,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{27,17}},"LCF"]

GraphData[{"ArcTransitive",{27,17}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{27,17}},"LCFSignature"]

GraphData[{"ArcTransitive",{27,17}},"LCFNotations"]

GraphData[{"ArcTransitive",{27,17}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{27,17}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{27,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{27,17}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{27,17}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{27,17}},"VertexList"],GraphData[{"ArcTransitive",{27,17}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{27,17}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{27,17}},"Matchstick"]

GraphData[{"ArcTransitive",{27,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{27,17}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{27,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{27,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{27,17}},"Polyhedral"]

GraphData[{"ArcTransitive",{27,17}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {27, 18}} == {"Complete", 27}

GraphData[{"ArcTransitive",{27,18}},"StandardName"]

{"ArcTransitive", {27, 19}} == {"Circulant", {27, {1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13}}}

GraphData[{"ArcTransitive",{27,19}},"StandardName"]

{"ArcTransitive", {27, 20}} == {"GeneralizedQuadrangle", {2, 4}}

GraphData[{"ArcTransitive",{27,20}},"StandardName"]

28

GraphData["ArcTransitive",28]

Cases[%,{"ArcTransitive",_}]

{"ArcTransitive", {28, 1}} == {"Cycle", 28}

GraphData[{"ArcTransitive",{28,1}},"StandardName"]

{"ArcTransitive", {28, 2}} == {"Circulant", {28, {1, 13}}}

GraphData[{"ArcTransitive",{28,2}},"StandardName"]

{"ArcTransitive", {28, 3}} == {"NoncayleyTransitive", {28, 2}}

GraphData[{"ArcTransitive",{28,3}},"StandardName"]

{"ArcTransitive", {28, 4}}

GraphData[{"ArcTransitive",{28,4}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{28,4}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{28,4}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

Bilateral

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

Circular

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

Planar

GraphData[{"ArcTransitive",{28,4}},"Planar"]

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

MinimalCrossing

GraphData[{"ArcTransitive",{28,4}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{28,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[{"ArcTransitive",{28,4}},"Circulant"]

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

Halin

GraphData[{"ArcTransitive",{28,4}},"Halin"]

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

Rigid

GraphData[{"ArcTransitive",{28,4}},"Rigid"]

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

Flexible

GraphData[{"ArcTransitive",{28,4}},"Flexible"]

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

LCF

GraphData[{"ArcTransitive",{28,4}},"LCF"]

GraphData[{"ArcTransitive",{28,4}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{28,4}},"LCFSignature"]

GraphData[{"ArcTransitive",{28,4}},"LCFNotations"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{28,4}},2,TimeConstraint->120]

LCF compute 10^5

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

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{28,4}}],10^6])[[All,2]]]//Timing

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

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}]]}]

LCF compute 10^7

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

LCF compute 5*^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{28,4}}],5*^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10^9."GB"

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[{BilateralLCFGraph@@#,#}&,Map[LCFGraph@@#&,SplitBy[DeleteCases[lcf,{_,1}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFGraph@@@Cases[lcf,{_,XXX}]]}]

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{28,4}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{28,4}},"VertexList"],GraphData[{"ArcTransitive",{28,4}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{28,4}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"ArcTransitive",{28,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"ArcTransitive",{28,4}},"Polyhedral"]

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

{"ArcTransitive", {28, 5}} == {"Circulant", {28, {1, 3, 9}}}

GraphData[{"ArcTransitive",{28,5}},"StandardName"]

{"ArcTransitive", {28, 6}}

GraphData[{"ArcTransitive",{28,6}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{28,6}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{28,6}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

GraphData[{"ArcTransitive",{28,6}},"Planar"]

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

MinimalCrossing

GraphData[{"ArcTransitive",{28,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{28,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[{"ArcTransitive",{28,6}},"Circulant"]

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

Halin

GraphData[{"ArcTransitive",{28,6}},"Halin"]

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

Rigid

GraphData[{"ArcTransitive",{28,6}},"Rigid"]

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

Flexible

GraphData[{"ArcTransitive",{28,6}},"Flexible"]

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

LCF

GraphData[{"ArcTransitive",{28,6}},"LCF"]

GraphData[{"ArcTransitive",{28,6}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{28,6}},"LCFSignature"]

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

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{28,6}},2,TimeConstraint->120]

LCF compute 10^5

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

LCF compute 10^6

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{28,6}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{28,6}},"VertexList"],GraphData[{"ArcTransitive",{28,6}},"EdgeList"]]]

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

g=RotateGraph[,{8,2}]

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{28,6}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"ArcTransitive",{28,6}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"ArcTransitive",{28,6}},"Polyhedral"]

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

{"ArcTransitive", {28, 7}} == {"Circulant", {28, {1, 6, 13}}}

GraphData[{"ArcTransitive",{28,7}},"StandardName"]

{"ArcTransitive", {28, 8}} == {"Circulant", {28, {1, 6, 8, 13}}}

GraphData[{"ArcTransitive",{28,8}},"StandardName"]

{"ArcTransitive", {28, 9}} == {"Circulant", {28, {1, 3, 5, 9, 11, 13}}}

GraphData[{"ArcTransitive",{28,9}},"StandardName"]

{"ArcTransitive", {28, 10}} == {"NoncayleyTransitive", {28, 25}}

GraphData[{"ArcTransitive",{28,10}},"StandardName"]

{"ArcTransitive", {28, 11}} == {"Triangular", 8}

GraphData[{"ArcTransitive",{28,11}},"StandardName"]

{"ArcTransitive", {28, 12}} == "CoxeterGraph"

GraphData[{"ArcTransitive",{28,12}},"StandardName"]

{"ArcTransitive", {28, 13}} == {"NoncayleyTransitive", {28, 7}}

GraphData[{"ArcTransitive",{28,13}},"StandardName"]

{"ArcTransitive", {28, 14}} == {"CompleteBipartite", {14, 14}}

GraphData[{"ArcTransitive",{28,14}},"StandardName"]

{"ArcTransitive", {28, 15}} == {"RookComplement", {4, 7}}

GraphData[{"ArcTransitive",{28,15}},"StandardName"]

{"ArcTransitive", {28, 16}} == {"CayleyGraph", {28, 1}}

GraphData[{"ArcTransitive",{28,16}},"StandardName"]

{"ArcTransitive", {28, 17}} == {"NoncayleyTransitive", {28, 9}}

GraphData[{"ArcTransitive",{28,17}},"StandardName"]

{"ArcTransitive", {28, 18}} == {"NoncayleyTransitive", {28, 13}}

GraphData[{"ArcTransitive",{28,18}},"StandardName"]

{"ArcTransitive", {28, 19}}

GraphData[{"ArcTransitive",{28,19}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{28,19}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{28,19}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{28,19}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{28,19}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{28,19}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{28,19}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{28,19}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{28,19}},"Planar"]

GraphData[{"ArcTransitive",{28,19}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{28,19}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{28,19}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{28,19}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{28,19}}],TimeConstraint->10])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{28,19}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{28,19}},"Circulant"]

GraphData[{"ArcTransitive",{28,19}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{28,19}},"Halin"]

GraphData[{"ArcTransitive",{28,19}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{28,19}},"Rigid"]

GraphData[{"ArcTransitive",{28,19}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{28,19}},"Flexible"]

GraphData[{"ArcTransitive",{28,19}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{28,19}},"LCF"]

GraphData[{"ArcTransitive",{28,19}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{28,19}},"LCFSignature"]

GraphData[{"ArcTransitive",{28,19}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{28,19}},2,TimeConstraint->120]

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{28,19}}],10^6])[[All,2]]]//Timing

LCF compute 10^7

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{28,19}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{28,19}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{28,19}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{28,19}},"VertexList"],GraphData[{"ArcTransitive",{28,19}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{28,19}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{28,19}},"Matchstick"]

GraphData[{"ArcTransitive",{28,19}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{28,19}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{28,19}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{28,19}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{28,19}},"Polyhedral"]

GraphData[{"ArcTransitive",{28,19}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {28, 20}} == {"Circulant", {28, {1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13}}}

GraphData[{"ArcTransitive",{28,20}},"StandardName"]

{"ArcTransitive", {28, 21}} == {"LocallyPaley", 13}

GraphData[{"ArcTransitive",{28,21}},"StandardName"]

{"ArcTransitive", {28, 22}} == {"Circulant", {28, {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14}}}

GraphData[{"ArcTransitive",{28,22}},"StandardName"]

{"ArcTransitive", {28, 23}} == {"Complete", 28}

GraphData[{"ArcTransitive",{28,23}},"StandardName"]

{"ArcTransitive", {28, 24}} == {"Crown", 14}

GraphData[{"ArcTransitive",{28,24}},"StandardName"]

{"ArcTransitive", {28, 25}} == {"CocktailParty", 14}

GraphData[{"ArcTransitive",{28,25}},"StandardName"]

{"ArcTransitive", {28, 26}} == {"Kneser", {8, 2}}

GraphData[{"ArcTransitive",{28,26}},"StandardName"]

29

GraphData["ArcTransitive",29]

Cases[%,{"ArcTransitive",_}]

30

GraphData["ArcTransitive",30]

Cases[%,{"ArcTransitive",_}]

{"ArcTransitive", {30, 1}} == {"Cycle", 30}

GraphData[{"ArcTransitive",{30,1}},"StandardName"]

{"ArcTransitive", {30, 2}} == {"Circulant", {30, {1, 11}}}

GraphData[{"ArcTransitive",{30,2}},"StandardName"]

{"ArcTransitive", {30, 3}} == {"CayleyGraph", {30, 4}}

GraphData[{"ArcTransitive",{30,3}},"StandardName"]

{"ArcTransitive", {30, 4}} == "IcosidodecahedralGraph"

GraphData[{"ArcTransitive",{30,4}},"StandardName"]

{"ArcTransitive", {30, 5}} == "DodecadodecahedralGraph"

Names

GraphData[{"ArcTransitive",{30,5}},"StandardName"]

GraphData[{"ArcTransitive",{30,5}},"StandardNames"]

{"ArcTransitive", {30, 6}} == {"Circulant", {30, {1, 14}}}

Names

GraphData[{"ArcTransitive",{30,6}},"StandardName"]

GraphData[{"ArcTransitive",{30,6}},"StandardNames"]

{"ArcTransitive", {30, 7}} == {"Circulant", {30, {1, 9, 11}}}

GraphData[{"ArcTransitive",{30,7}},"StandardName"]

{"ArcTransitive", {30, 8}} == {"Circulant", {30, {1, 7, 11, 13}}}

GraphData[{"ArcTransitive",{30,8}},"StandardName"]

{"ArcTransitive", {30, 9}} == {"Circulant", {30, {1, 4, 11, 14}}}

GraphData[{"ArcTransitive",{30,9}},"StandardName"]

{"ArcTransitive", {30, 10}}

GraphData[{"ArcTransitive",{30,10}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{30,10}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,10}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,10}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,10}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,10}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,10}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,10}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,10}},"Planar"]

GraphData[{"ArcTransitive",{30,10}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,10}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,10}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

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

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,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[{"ArcTransitive",{30,10}},"Circulant"]

GraphData[{"ArcTransitive",{30,10}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,10}},"Halin"]

GraphData[{"ArcTransitive",{30,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,10}},"Rigid"]

GraphData[{"ArcTransitive",{30,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,10}},"Flexible"]

GraphData[{"ArcTransitive",{30,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,10}},"LCF"]

GraphData[{"ArcTransitive",{30,10}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,10}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,10}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,10}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,10}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,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,{_,1}]]}])//Timing

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{30,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,10}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,10}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,10}},"VertexList"],GraphData[{"ArcTransitive",{30,10}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"ArcTransitive",{30,10}},"Matchstick"]

GraphData[{"ArcTransitive",{30,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,10}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,10}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,10}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 11}} == "DesarguesLineGraph"

GraphData[{"ArcTransitive",{30,11}},"StandardName"]

{"ArcTransitive", {30, 12}} == {"PGIncidenceComplement", {3, 2}}

GraphData[{"ArcTransitive",{30,12}},"StandardName"]

{"ArcTransitive", {30, 13}}

GraphData[{"ArcTransitive",{30,13}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{30,13}},"Graph","All"]//StyleGraphs

Inexact

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

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,13}},"Edges"]

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

RecognizeGraph[g]

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,13}},"EdgeList"]]

Degenerate

GraphData[{"ArcTransitive",{30,13}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{30,13}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,13}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,13}},"Planar"]

GraphData[{"ArcTransitive",{30,13}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,13}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,13}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

CrossingNumber[GraphData[{"ArcTransitive",{30,13}}],TimeConstraint->60]//AbsoluteTiming

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,13}},"Circulant"]

GraphData[{"ArcTransitive",{30,13}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,13}},"Halin"]

GraphData[{"ArcTransitive",{30,13}},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,13}},"LCF"]

GraphData[{"ArcTransitive",{30,13}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,13}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,13}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,13}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,13}},2,TimeConstraint->120]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{30,13}}],All][[All,All,1]]]//Timing

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

DeleteCases[lcf,{_,1}]

Length[%]

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|3}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFEmbedding/@LCFGraph@@@Cases[lcf,{_,3}]]}])//Timing

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{30,13}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,13}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,13}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine/@GraphData[{"ArcTransitive",{30,13}},"Graph","All"]

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"ArcTransitive",{30,13}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,13}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,13}}],MaxIterations->50000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"ArcTransitive",{30,13}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,13}}],TimeConstraint->300,"Results"->All]//Timing}

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

Matchstick

GraphData[{"ArcTransitive",{30,13}},"Matchstick"]

GraphData[{"ArcTransitive",{30,13}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,13}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,13}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,13}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,13}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,13}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 14}}

GraphData[{"ArcTransitive",{30,14}},"StandardName"]

Primary

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

All

GraphData[{"ArcTransitive",{30,14}},"Graph","All"]//StyleGraphs

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,14}},"Edges"]

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

RecognizeGraph[g]

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,14}},"EdgeList"]]

Degenerate

GraphData[{"ArcTransitive",{30,14}},"Graph","Degenerate"]//StyleGraphs

Bilateral

GraphData[{"ArcTransitive",{30,14}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,14}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,14}},"Planar"]

GraphData[{"ArcTransitive",{30,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,14}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

CrossingNumber[GraphData[{"ArcTransitive",{30,14}}],TimeConstraint->60]//AbsoluteTiming

g=RotateGraph[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,14}}],"CrossingNumber"->cn]]

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,14}},"Circulant"]

GraphData[{"ArcTransitive",{30,14}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,14}},"Halin"]

GraphData[{"ArcTransitive",{30,14}},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,14}},"LCF"]

GraphData[{"ArcTransitive",{30,14}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,14}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,14}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,14}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,14}},2,TimeConstraint->120]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{30,14}}],All][[All,All,1]]]//Timing

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{30,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,14}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,14}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine/@GraphData[{"ArcTransitive",{30,14}},"Graph","All"]

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"ArcTransitive",{30,14}},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,14}}],MaxIterations->50000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"ArcTransitive",{30,14}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,14}}],TimeConstraint->300,"Results"->All]//Timing}

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

Matchstick

GraphData[{"ArcTransitive",{30,14}},"Matchstick"]

GraphData[{"ArcTransitive",{30,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,14}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,14}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,14}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 15}} == {"Circulant", {30, {1, 5, 7, 11, 13}}}

GraphData[{"ArcTransitive",{30,15}},"StandardName"]

{"ArcTransitive", {30, 16}}

GraphData[{"ArcTransitive",{30,16}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{30,16}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,16}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,16}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,16}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,16}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,16}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,16}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,16}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,16}},"Planar"]

GraphData[{"ArcTransitive",{30,16}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,16}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,16}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,16}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,16}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,16}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,16}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,16}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,16}},"Circulant"]

GraphData[{"ArcTransitive",{30,16}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,16}},"Halin"]

GraphData[{"ArcTransitive",{30,16}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,16}},"Rigid"]

GraphData[{"ArcTransitive",{30,16}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,16}},"Flexible"]

GraphData[{"ArcTransitive",{30,16}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,16}},"LCF"]

GraphData[{"ArcTransitive",{30,16}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,16}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,16}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,16}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,16}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,16}}],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]

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"ArcTransitive",{30,16}},"UnitDistance"]

GraphData[{"ArcTransitive",{30,16}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,16}},"VertexList"],GraphData[{"ArcTransitive",{30,16}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,16}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,16}},"Matchstick"]

GraphData[{"ArcTransitive",{30,16}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,16}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,16}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,16}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,16}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,16}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 17}}

GraphData[{"ArcTransitive",{30,17}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{30,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,17}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,17}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,17}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,17}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,17}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,17}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,17}},"Planar"]

GraphData[{"ArcTransitive",{30,17}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,17}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,17}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,17}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,17}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,17}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,17}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,17}},"Circulant"]

GraphData[{"ArcTransitive",{30,17}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,17}},"Halin"]

GraphData[{"ArcTransitive",{30,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,17}},"Rigid"]

GraphData[{"ArcTransitive",{30,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,17}},"Flexible"]

GraphData[{"ArcTransitive",{30,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,17}},"LCF"]

GraphData[{"ArcTransitive",{30,17}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,17}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,17}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,17}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,17}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

DeleteCases[lcf,{_,1}]

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{30,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,17}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,17}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,17}},"VertexList"],GraphData[{"ArcTransitive",{30,17}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,17}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,17}},"Matchstick"]

GraphData[{"ArcTransitive",{30,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,17}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,17}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,17}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 18}} == {"Circulant", {30, {1, 3, 7, 9, 11, 13}}}

GraphData[{"ArcTransitive",{30,18}},"StandardName"]

{"ArcTransitive", {30, 19}} == {"Circulant", {30, {1, 2, 4, 7, 8, 11, 13, 14}}}

GraphData[{"ArcTransitive",{30,19}},"StandardName"]

{"ArcTransitive", {30, 20}} == {"Arrangement", {6, 2}}

GraphData[{"ArcTransitive",{30,20}},"StandardName"]

{"ArcTransitive", {30, 21}} == {"Circulant", {30, {1, 4, 9, 11, 14}}}

GraphData[{"ArcTransitive",{30,21}},"StandardName"]

{"ArcTransitive", {30, 22}} == {"CompleteTripartite", {10, 10, 10}}

GraphData[{"ArcTransitive",{30,22}},"StandardName"]

{"ArcTransitive", {30, 23}}

Names

GraphData[{"ArcTransitive",{30,23}},"StandardName"]

GraphData[{"ArcTransitive",{30,23}},"StandardNames"]

Primary

GraphData[{"ArcTransitive",{30,23}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,23}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,23}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,23}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,23}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,23}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,23}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,23}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,23}},"Planar"]

GraphData[{"ArcTransitive",{30,23}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,23}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,23}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,23}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,23}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,23}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,23}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,23}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,23}},"Circulant"]

GraphData[{"ArcTransitive",{30,23}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,23}},"Halin"]

GraphData[{"ArcTransitive",{30,23}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,23}},"Rigid"]

GraphData[{"ArcTransitive",{30,23}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,23}},"Flexible"]

GraphData[{"ArcTransitive",{30,23}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,23}},"LCF"]

GraphData[{"ArcTransitive",{30,23}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,23}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,23}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,23}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,23}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

Length[gs]

LCF compute 10^7

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

Length[gs]

LCF compute 5*^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,23}}],5*^7])[[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]

LCF compute all

Divisors[GraphData[{"ArcTransitive",{30,23}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"ArcTransitive",{30,23}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"ArcTransitive",{30,23}},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

UnitDistance

GraphData[{"ArcTransitive",{30,23}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,23}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,23}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,23}},"VertexList"],GraphData[{"ArcTransitive",{30,23}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,23}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,23}},"Matchstick"]

GraphData[{"ArcTransitive",{30,23}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,23}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,23}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,23}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,23}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,23}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 24}} == {"CompleteBipartite", {15, 15}}

GraphData[{"ArcTransitive",{30,24}},"StandardName"]

{"ArcTransitive", {30, 25}} == "Tutte8Cage"

GraphData[{"ArcTransitive",{30,25}},"StandardName"]

{"ArcTransitive", {30, 26}}

GraphData[{"ArcTransitive",{30,26}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{30,26}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,26}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,26}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,26}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,26}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,26}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,26}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,26}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,26}},"Planar"]

GraphData[{"ArcTransitive",{30,26}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,26}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,26}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,26}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,26}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,26}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,26}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,26}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,26}},"Circulant"]

GraphData[{"ArcTransitive",{30,26}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,26}},"Halin"]

GraphData[{"ArcTransitive",{30,26}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,26}},"Rigid"]

GraphData[{"ArcTransitive",{30,26}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,26}},"Flexible"]

GraphData[{"ArcTransitive",{30,26}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,26}},"LCF"]

GraphData[{"ArcTransitive",{30,26}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,26}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,26}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,26}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,26}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,26}}],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[{"ArcTransitive",{30,26}},"UnitDistance"]

GraphData[{"ArcTransitive",{30,26}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,26}},"VertexList"],GraphData[{"ArcTransitive",{30,26}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,26}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,26}},"Matchstick"]

GraphData[{"ArcTransitive",{30,26}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,26}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,26}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,26}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,26}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,26}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 27}} == {"BipartiteKneser", {6, 2}}

GraphData[{"ArcTransitive",{30,27}},"StandardName"]

{"ArcTransitive", {30, 28}}

GraphData[{"ArcTransitive",{30,28}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{30,28}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,28}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,28}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,28}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,28}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,28}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,28}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,28}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,28}},"Planar"]

GraphData[{"ArcTransitive",{30,28}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,28}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,28}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,28}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,28}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,28}}],TimeConstraint->60])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,28}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,28}},"Circulant"]

GraphData[{"ArcTransitive",{30,28}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,28}},"Halin"]

GraphData[{"ArcTransitive",{30,28}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,28}},"Rigid"]

GraphData[{"ArcTransitive",{30,28}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,28}},"Flexible"]

GraphData[{"ArcTransitive",{30,28}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,28}},"LCF"]

GraphData[{"ArcTransitive",{30,28}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,28}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,28}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,28}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,28}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,28}}],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[{"ArcTransitive",{30,28}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,28}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,28}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceGraphEmbeddingQ[%]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,28}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,28}},"Matchstick"]

GraphData[{"ArcTransitive",{30,28}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,28}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,28}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,28}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,28}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,28}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 29}} == {"RookComplement", {3, 10}}

GraphData[{"ArcTransitive",{30,29}},"StandardName"]

{"ArcTransitive", {30, 30}} == {"RookComplement", {5, 6}}

GraphData[{"ArcTransitive",{30,30}},"StandardName"]

{"ArcTransitive", {30, 31}}

GraphData[{"ArcTransitive",{30,31}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{30,31}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,31}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,31}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,31}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,31}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,31}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,31}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,31}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,31}},"Planar"]

GraphData[{"ArcTransitive",{30,31}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,31}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,31}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,31}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,31}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,31}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,31}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,31}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,31}},"Circulant"]

GraphData[{"ArcTransitive",{30,31}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,31}},"Halin"]

GraphData[{"ArcTransitive",{30,31}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,31}},"Rigid"]

GraphData[{"ArcTransitive",{30,31}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,31}},"Flexible"]

GraphData[{"ArcTransitive",{30,31}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,31}},"LCF"]

GraphData[{"ArcTransitive",{30,31}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,31}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,31}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,31}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,31}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

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

DeleteCases[lcf,{_,1}]

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

GraphData[{"ArcTransitive",{30,31}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,31}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,31}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,31}},"VertexList"],GraphData[{"ArcTransitive",{30,31}},"EdgeList"]]]

cg=LabelGraph@ContractCoincidentVertices[]

RecognizeGraph[cg]

GraphPlot@

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,31}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,31}},"Matchstick"]

GraphData[{"ArcTransitive",{30,31}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,31}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,31}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,31}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,31}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,31}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 32}} == {"Circulant", {30, {1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}}}

GraphData[{"ArcTransitive",{30,32}},"StandardName"]

{"ArcTransitive", {30, 33}} == {"Circulant", {30, {1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15}}}

GraphData[{"ArcTransitive",{30,33}},"StandardName"]

{"ArcTransitive", {30, 34}}

Names

GraphData[{"ArcTransitive",{30,34}},"StandardName"]

GraphData[{"ArcTransitive",{30,34}},"StandardNames"]

Primary

GraphData[{"ArcTransitive",{30,34}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,34}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,34}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,34}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,34}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,34}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,34}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,34}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,34}},"Planar"]

GraphData[{"ArcTransitive",{30,34}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,34}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,34}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,34}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,34}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,34}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,34}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,34}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,34}},"Circulant"]

GraphData[{"ArcTransitive",{30,34}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,34}},"Halin"]

GraphData[{"ArcTransitive",{30,34}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,34}},"Rigid"]

GraphData[{"ArcTransitive",{30,34}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,34}},"Flexible"]

GraphData[{"ArcTransitive",{30,34}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,34}},"LCF"]

GraphData[{"ArcTransitive",{30,34}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,34}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,34}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,34}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,34}},2,TimeConstraint->120]

lcf={{{-14,-12,-9,-7,3,9,14},{-9,-6,3,5,7,9,14},{-13,-8,-6,-4,7,9,11},{-11,-8,-3,3,5,7,12},{-14,-7,-3,3,5,8,13},{-14,-12,-6,3,6,8,14},{-9,-5,-3,3,6,11,14},{-13,-11,-9,-3,7,9,11},{-11,-7,-5,-3,4,9,12},{-14,-9,-7,-5,-3,6,13}},3};

g=LCFGraph@@lcf

BilateralLCFGraph@@lcf

l={{{"ArcTransitive",{30,34}},{0,Missing["NotAvailable",{lcf}]}}}

PropertyReplace[l,"LCFNotations","13.3"]

RenameGraphFiles[]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,34}}],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]

LCF compute 5*^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,34}}],5*^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9"GB"

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[{"ArcTransitive",{30,34}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,34}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,34}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,34}},"VertexList"],GraphData[{"ArcTransitive",{30,34}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,34}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,34}},"Matchstick"]

GraphData[{"ArcTransitive",{30,34}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,34}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,34}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,34}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,34}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,34}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 35}}

GraphData[{"ArcTransitive",{30,35}},"StandardName"]

Primary

GraphData[{"ArcTransitive",{30,35}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"ArcTransitive",{30,35}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"ArcTransitive",{30,35}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"ArcTransitive",{30,35}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"ArcTransitive",{30,35}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"ArcTransitive",{30,35}},"Graph","Degenerate"]

Bilateral

GraphData[{"ArcTransitive",{30,35}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"ArcTransitive",{30,35}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"ArcTransitive",{30,35}},"Planar"]

GraphData[{"ArcTransitive",{30,35}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"ArcTransitive",{30,35}},{"RCN","CN"}]

GraphData[{"ArcTransitive",{30,35}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,35}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,35}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,35}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"ArcTransitive",{30,35}}],TimeConstraint->3600])//AbsoluteTiming

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

Table[MinimalCrossingGraph[GraphData[{"ArcTransitive",{30,35}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"ArcTransitive",{30,35}},"Circulant"]

GraphData[{"ArcTransitive",{30,35}},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"ArcTransitive",{30,35}},"Halin"]

GraphData[{"ArcTransitive",{30,35}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"ArcTransitive",{30,35}},"Rigid"]

GraphData[{"ArcTransitive",{30,35}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"ArcTransitive",{30,35}},"Flexible"]

GraphData[{"ArcTransitive",{30,35}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"ArcTransitive",{30,35}},"LCF"]

GraphData[{"ArcTransitive",{30,35}},"HamiltonianCycleCount"]

GraphData[{"ArcTransitive",{30,35}},"LCFSignature"]

GraphData[{"ArcTransitive",{30,35}},"LCFNotations"]

GraphData[{"ArcTransitive",{30,35}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

ComputeRandomLCFNotation[{"ArcTransitive",{30,35}},2,TimeConstraint->120]

LCF compute 10^5

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

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"ArcTransitive",{30,35}}],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[{"ArcTransitive",{30,35}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"ArcTransitive",{30,35}}],Debug->True]//Timing

GraphData[{"ArcTransitive",{30,35}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"ArcTransitive",{30,35}},"VertexList"],GraphData[{"ArcTransitive",{30,35}},"EdgeList"]]]

g=LabelGraph@IndexGraph@ContractCoincidentVertices[]

RecognizeGraph@g

GraphPlot@RotateGraph[,Pi/10]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"ArcTransitive",{30,35}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

Matchstick

GraphData[{"ArcTransitive",{30,35}},"Matchstick"]

GraphData[{"ArcTransitive",{30,35}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"ArcTransitive",{30,35}},"Edges"]]

3D All

GraphData[{"ArcTransitive",{30,35}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"ArcTransitive",{30,35}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"ArcTransitive",{30,35}},"Polyhedral"]

GraphData[{"ArcTransitive",{30,35}},"Graph",{"3D","Polyhedron"}]

{"ArcTransitive", {30, 36}} == {"DifferenceSetIncidence", {15, 7, 3}}

GraphData[{"ArcTransitive",{30,36}},"StandardName"]

{"ArcTransitive", {30, 37}} == {"Crown", 15}

GraphData[{"ArcTransitive",{30,37}},"StandardName"]

{"ArcTransitive", {30, 38}} == {"Circulant", {30, {1, 4, 6, 9, 11, 14}}}

GraphData[{"ArcTransitive",{30,38}},"StandardName"]

{"ArcTransitive", {30, 39}} == {"Complete", 30}

GraphData[{"ArcTransitive",{30,39}},"StandardName"]

{"ArcTransitive", {30, 40}} == {"Circulant", {30, {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15}}}

GraphData[{"ArcTransitive",{30,40}},"StandardName"]

{"ArcTransitive", {30, 41}} == {"CocktailParty", 15}

GraphData[{"ArcTransitive",{30,41}},"StandardName"]

31

GraphData["ArcTransitive",31]

Cases[%,{"ArcTransitive",_}]

32

GraphData["ArcTransitive",32]

Cases[%,{"ArcTransitive",_}]

GraphData

GraphDataString

file=OpenWrite["~/arc-transitive.m"]

new[[All,2]]

WriteString[file,GraphDataString[#,
"StandardName"->#2,
"Embeddings"->{},
"EmbeddingClasses"->{},
"Name"->ToString[#2[[2,1]]]<>"\[Hyphen]arc transitive graph "<>ToString[#2[[2,2]]],
"Information"->"Arc-TransitiveGraph",
"Classes"->{"ArcTransitive"},
"NotationRules"->{Rule@@#2},
"Skip"->{"Arboricity"},
TimeConstraint->10,
Debug->True]]&@@@new//Timing

Close[file]