Edge-Transitive Graph

Author

Eric W. Weisstein
March 11, 2024

This notebook downloaded from http://mathworld.wolfram.com/notebooks/GraphTheory/Edge-TransitiveGraph.nb.

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

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

Classes

GraphClassesThatAreClass["EdgeTransitive"]

Counts

All

A095352

1,2,4,8,12,21,27,39,50,69

Total[Boole[Get[#]]]&/@FileNames["*.m",FileNameJoin[{$GraphDataDirectory,"Nodes","EdgeTransitive"}]]

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

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

Missing from GraphData

Length/@et-%373

Next terms in OEIS must be >=

Table[Length@GraphData["EdgeTransitive",n],{n,11,30}]

Connected

A095424

seq={1,1,2,3,4,6,5,8,9,13,7,19,10,16,25,26,12,28,12,43};

Table[Total[Boole[Get[FileNameJoin[{$GraphDataDirectory,"Nodes","EdgeTransitive","EdgeTransitive_"<>If[n<10,"0",""]<>ToString[n]<>".m"}]][[ConnectedGraphIndices[n]]]]],{n,9}]

Length/@Table[GraphData[{"Connected","EdgeTransitive"},n],{n,20}]

seq-%

Next terms must be at least

Table[Length@GraphData[{"Connected","EdgeTransitive"},n],{n,21,25}]

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

Disconnected

Not in OEIS 2017-10-28

Table[Total[Boole[Get[FileNameJoin[{$GraphDataDirectory,"Nodes","EdgeTransitive","EdgeTransitive_"<>If[n<10,"0",""]<>ToString[n]<>".m"}]][[DisconnectedGraphIndices[n]]]]],{n,9}]

Simple

Load simple graphs

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

Compute

Table[GraphData["EdgeTransitive",n],{n,10}]//Column

Table[GraphData["EdgeTransitive",n],{n,8}]

Map[GraphData[#,"Notation"]&,Table[GraphData["EdgeTransitive",n],{n,10}],{2}]/.s_String?(StringMatchQ[#,LetterCharacter]&):>Style[s,Italic]//Column//TraditionalForm

et=Table[Pick[Graphs[n],EdgeTransitiveGraphQ/@Graphs[n]],{n,10}]

Missing graphs

Cases[et/.g_`Graph:>ToEntity[g],ToEntity[g_]:>g,Infinity]//Quiet

Length/@SplitBy[{VertexCount[#],#}&/@%,First]

Figure

et=Table[Pick[Graphs[n],EdgeTransitiveGraphQ/@Graphs[n]],{n,5}];

plotgraph[g_System`Graph]:=Module[{e=ToEntity[g]},
If[Head[e]===Entity,GraphData[e],g]//Quiet
]

GraphicsGrid[Flatten[Partition[#,UpTo[8]]&/@Map[Show[#//StyleGraphs,PlotLabel->TextCell[GraphData[RecognizeGraph@#,"Name"],PageWidth->70,TextAlignment->Center],LabelStyle->Directive[Black,Italic,FontFamily->"Times",8]]&,Take[et,5],{2}],1],ImageSize->600,Dividers->All,Alignment->Center]

Connected figure

Figure

GraphicsGrid[Flatten[Partition[#,UpTo[8]]&/@Map[Show[GraphData[#]//StyleGraphs,PlotLabel->TextCell[GraphData[#,"Name"],PageWidth->90,TextAlignment->Center],LabelStyle->Directive[Italic,Black,FontFamily->"Times"]]&,Table[GraphData[{"Connected","EdgeTransitive"},n],{n,7}],{2}],1],ImageSize->600,Dividers->All]

Table with graph names

Grid[Flatten[Table[{n,#[[1,1]],Length[gs=#[[All,2]]],#}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@GraphData[{"Connected","EdgeTransitive"},n]],First],{n,20}],1],Dividers->All,Alignment->{{Decimal,Decimal,Decimal,Left}}]

Complement graph is a named graph

Grid[DeleteCases[{#,GraphData[#,"ComplementGraph","Name"]}&/@GraphData[{"Connected","EdgeTransitive"},;;20],{_,_Missing}],Dividers->All,Alignment->Left]

Line graph is a named graph

Grid[DeleteCases[{#,GraphData[#,"LineGraph","Name"]}&/@GraphData[{"Connected","EdgeTransitive"},;;20],{_,_Missing}],Dividers->All,Alignment->Left]

Table with embeddings

Grid[Flatten[Table[{n,#[[1,1]],Length[gs=#[[All,2]]],(#->Show[GraphData[#],ImageSize->Tiny])&/@gs}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@GraphData[{"Connected","EdgeTransitive"},n]],First],{n,20}],1],Dividers->All,Alignment->{{Decimal,Decimal,Decimal,Left}}]

Table with Notations

Map[GraphData[#,"Notation"]&,Table[GraphData[{"Connected","EdgeTransitive"},n],{n,20}],{2}]/.s_String?(StringLength[#]==1&):>Style[s,Italic]//Column//TraditionalForm

Code

k[l__,opts___?OptionQ]:=System`CompleteGraph[{l},opts]

CompleteBipartiteSubgraph[{i_,j_},{m_,n_},nspec_:1,opts___?OptionQ]:=Module[{g=System`CompleteGraph[{m,n}],h,s,rules,elist,ec=m n,o,del,sizes,
degrees=Sort[Join[ConstantArray[i,m],ConstantArray[j,n]]],
debug=Debug/.{opts}/.Debug->False,
maxsize="MaxSize"/.{opts}/."MaxSize"->2*^9
},
elist=EdgeList[g];
rules=Thread[Range[ec]->elist];
sizes={((Binomial[n,i])^m),((Binomial[m,j])^n)};
If[Min[sizes]>maxsize,Print["Minimum set size ",Min[sizes], " is larger than maxsize ",maxsize];Return[$Failed]];
s=If[Less@@sizes,
(* delete n-i edges from each node on left side *)
If[debug,Print["left"]];
Table[Subsets[UndirectedEdge@@Sort[{k,#}]&/@AdjacencyList[g,k],{n-i}],{k,m}],
(* delete m-j edges from each node on right side *)
If[debug,Print["right"]];
Table[Subsets[UndirectedEdge@@Sort[{k,#}]&/@AdjacencyList[g,k],{m-j}],{k,m+1,m+n}]
];
If[debug,Print[s]];
s=Developer`ToPackedArray[s/.Thread[elist->Range[ec]]];
o=Flatten[Outer[List,Sequence@@s,1],Length[s]-1];
del=Select[o,Sort[VertexDegree[h=EdgeDelete[g,Flatten[#/.rules]]]]===degrees&&ConnectedGraphQ[h]&&EdgeTransitiveGraphQ[h]&,nspec];
EdgeDelete[g,Flatten[#/.rules]]&/@del
]

ReadEdgeTransitiveAdjacencyLists[n_,file_:""]:=Module[{
string=StringReplace[Import["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/EdgeTransitive/"<>If[file==="",ToString[n]<>"\ et\ graphs.rtf",file],"String"],{"}"->"","\\\n"->""}],
l
},
l=(StringReplace[#,RegularExpression[" *\\d+ : (.+);"]:>(StringSplit["$1"])]&/@(StringSplit[StringTrim[#],"\r"]&/@(StringSplit[#,"\r\r"][[1]]&/@Rest[StringSplit[string,"\\b0"]])))/.StringExpression[l_]:>(1+ToExpression[l]);
MyFromAdjacencyLists/@l
]

ReadEdgeTransitiveAdjacencyLists[20,file:"20 et graphs.txt"]:=Module[{string=StringReplace[Import["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/EdgeTransitive/20 et graphs.txt","String"],{"\t"->"","\r\n"->"\n"}]},
l=(StringReplace[#,RegularExpression[" *\\d+ : (.+);"]:>(StringSplit["$1"])]&/@Rest[StringSplit[#,"\n"]])&/@Rest[StringSplit[string,StartOfLine~~"Graph"]]/.StringExpression[l_]:>(1+ToExpression[l]);
MyFromAdjacencyLists/@l
]

ReadEdgeTransitiveEdgeLists[n_,file_:""]:=Module[{
string=StringReplace[Import["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/EdgeTransitive/"<>If[file==="",ToString[n]<>"\ et\ graphs.rtf",file],"String"],{"}"->"","\\\n"->""}],
l
},
l=StringSplit[Rest[StringSplit[string,"\\b0"]],{"\\b","\n"}];
IndexGraph[System`Graph[Sort/@ToExpression["{"<>#[[1]]<>"}"]]]&/@l
]

9-node (9 graphs)

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},9]

Length[etgd]

TextGrid[{#,Cases[GraphData[#,"StandardNames"],{"EdgeTransitive",_}]}&/@etgd,Alignment->Left,Dividers->All]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[9]={
GraphData["S9"],
GraphData["C9"],
GraphData[{"EdgeTransitive",{9,14}}],
k[2,7],
{k[3,6],GraphData["GQ2,1"]},
k[4,5],
k[3,3,3],
k[9]
};

Grid[{Union[EdgeCount/@DeleteMissing[#]],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@et[9]),Dividers->All,Alignment->Left]//Quiet

New one

g0=cet[[3]]

EdgeTransitiveQ[g0]

g=Graph[Range[9],UndirectedEdge@@@Sort/@Join[
Partition[{1,4,2,5,3,6},2,1,1],
Partition[{6,7,4,8,5,9},2,1,1]
],
VertexCoordinates->Join[p=CirclePoints[3],p2=Mean/@Partition[p,2,1,1],p/2],VertexLabels->"Name"
]

List@@@EdgeList[g]

EdgeTransitiveQ[g]

IsomorphicGraphQ[g,g0]

emb=GraphEmbedding[g];

g2=Graph[VertexList[g],EdgeList[g],VertexLabels->"Name",VertexCoordinates->Join[{emb[[{4,6}]]//Mean,emb[[{4,5}]]//Mean,emb[[{5,6}]]//Mean},Drop[emb,3]]]

12-node (19 graphs)

(4,2) Subgraph of (Subscript[K, 4,8])

CompleteBipartiteSubgraph[{4,2},{4,8}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

System`Graph[EdgeList[CompleteBipartiteSubgraph[{4,2},{4,8}][[1]]]]

Mean/@Partition[c,2,1,1]

Graphics[{Point[c=CirclePoints[4]],MapIndexed[Text[#2[[1]],#+.1]&,c],Point[m=Mean/@Partition[c,2,1,1]],MapIndexed[Text[#2[[1]],#+.1]&,m]}]

K48Subgraph42=System`Graph[Range[12],Join@@(Partition[#,2,1,1]&/@{{1,5,2,6,3,7,4,8},{5,9,6,10,7,11,8,12}}),VertexCoordinates->Join[c,m,Mean/@Partition[m,2,1,1]],VertexLabels->"Name"]

IsomorphicGraphQ[,K48Subgraph42]

CompleteBipartiteSubgraph[{4,2},{4,8}]

Union[CanonicalGraph/@CompleteBipartiteSubgraph[{4,2},{4,8},Infinity]]//Timing

g=System`CompleteGraph[{4,8},VertexLabels->"Name"]

VertexDegree[g]

Delete 4 edges from left:

((Binomial[8,4])^4)

Delete 2 edges from right:

((Binomial[4,2])^8)

s=Table[Subsets[UndirectedEdge@@Sort[{n,#}]&/@AdjacencyList[g,n],{2}],{n,5,12}]

s2=Developer`ToPackedArray[s/.Thread[EdgeList[g]->Range[EdgeCount[g]]]]

o=Flatten[Outer[List,Sequence@@s2,1],7];

ByteCount[o]

Length[o]

rules=Thread[Range[EdgeCount[g]]->EdgeList[g]]

o[[1]]/.rules

degrees=Sort[Join[ConstantArray[2,8],ConstantArray[4,4]]]

(del=SelectFirst[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&EdgeTransitiveGraphQ[gg]&])//Timing

(del=SelectFirst[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&Sort[VertexDegree[gg]]===degrees&&EdgeTransitiveGraphQ[gg]&])//Timing

(del=SelectFirst[o,Sort[VertexDegree[gg=EdgeDelete[g,Flatten[#/.rules]]]]===degrees&&ConnectedGraphQ[gg]&&EdgeTransitiveGraphQ[gg]&])//Timing

del/.rules

(delall=Select[o,Sort[VertexDegree[gg=EdgeDelete[g,Flatten[#/.rules]]]]==={2,2,2,2,2,2,2,2,4,4,4,4}&&ConnectedGraphQ[gg]&&EdgeTransitiveGraphQ[gg]&])//Timing

Length[delall]

Take[delall,10]/.rules

CompleteBipartiteSubgraph[{4,2},{4,8}]=EdgeDelete[g,Flatten[del/.rules]]

//EdgeCount

RecognizeGraph[CompleteBipartiteSubgraph[{4,2},{4,8}]]

VertexDegree[CompleteBipartiteSubgraph[{4,2},{4,8}]]//Sort

EdgeTransitiveGraphQ[CompleteBipartiteSubgraph[{4,2},{4,8}]]

(6,2) Subgraph of (Subscript[K, 3,9])

CompleteBipartiteSubgraph[{6,2},{3,9}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

//Head

EdgeList[]

System`Graph[EdgeList[]]

System`Graph[EdgeList[],GraphLayout->"TutteEmbedding",VertexLabels->"Name"]

Graphics[{Point[c=CirclePoints[{1,π/6},6]],MapIndexed[Text[#2[[1]],#+.1]&,c],Point[m=Mean/@Partition[c[[2;;All;;2]],2,1,1]],MapIndexed[Text[#2[[1]],#+.1]&,m]}]

Mean/@Partition[c[[2;;All;;2]],2,1,1]

Join[c,m,Mean/@{c[[1]]+m[[3]],c[[3]]+m[[1]],c[[5]]+m[[2]]}]

K39Subgraph62=System`Graph[Range[12],Sort/@Join@@(Partition[#,2,1,1]&/@{Range[6],{4,8,6,9,2,7},{6,10,2,11,4,12}}),VertexCoordinates->Join[c,m,Mean/@{{c[[1]],m[[3]]},{c[[3]],m[[1]]},{c[[5]],m[[2]]}}],VertexLabels->"Name"]

IsomorphicGraphQ[,K39Subgraph62]

g=System`CompleteGraph[{3,9},VertexLabels->"Name"]

VertexDegree[g]

Delete 3 edges from left:

((Binomial[9,3])^3)

Delete 1 edge from right:

((Binomial[3,1])^9)

s=Table[Subsets[UndirectedEdge@@Sort[{n,#}]&/@AdjacencyList[g,n],{1}],{n,4,12}]

s2=Developer`ToPackedArray[s/.Thread[EdgeList[g]->Range[EdgeCount[g]]]]

o=Flatten[Outer[List,Sequence@@s2,1],8];

ByteCount[o]

Length[o]

rules=Thread[Range[EdgeCount[g]]->EdgeList[g]]

(del=SelectFirst[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&EdgeTransitiveGraphQ[gg]&])//Timing

degs=Sort[Join[ConstantArray[6,3],ConstantArray[2,9]]]

(del=SelectFirst[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&Sort[VertexDegree[gg]]===degs&&EdgeTransitiveGraphQ[gg]&])//Timing

(del=SelectFirst[o,Sort[VertexDegree[gg=EdgeDelete[g,Flatten[#/.rules]]]]===degs&&ConnectedGraphQ[gg]&&EdgeTransitiveGraphQ[gg]&])//Timing

del/.rules

(delall=Select[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&Sort[VertexDegree[gg]]==={2,2,2,2,2,2,2,2,4,4,4,4}&&EdgeTransitiveGraphQ[gg]&])//Timing

CompleteBipartiteSubgraph[{6,2},{3,9}]=EdgeDelete[g,Flatten[del/.rules]]

RecognizeGraph[K39Subgraph62]

VertexDegree[K39Subgraph62]//Sort

EdgeTransitiveGraphQ[K39Subgraph62]

(6,3) Subgraph of (Subscript[K, 4,8])

CompleteBipartiteSubgraph[{6,3},{4,8}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

PlanarGraphQ[]

HamiltonianGraphQ[]

System`Graph[EdgeList[]]

g=System`CompleteGraph[{4,8},VertexLabels->"Name"]

VertexDegree[g]

((Binomial[8,4])^4)

((Binomial[4,3])^8)

s=Table[Subsets[UndirectedEdge@@Sort[{n,#}]&/@AdjacencyList[g,n],{1}],{n,5,12}]

s2=Developer`ToPackedArray[s/.Thread[EdgeList[g]->Range[EdgeCount[g]]]]

o=Flatten[Outer[List,Sequence@@s2,1],7];

ByteCount[o]

Length[o]

rules=Thread[Range[EdgeCount[g]]->EdgeList[g]]

degrees=Join[ConstantArray[3,8],ConstantArray[6,4]]

(del=SelectFirst[o,Sort[VertexDegree[gg=EdgeDelete[g,Flatten[#/.rules]]]]===degrees&&ConnectedGraphQ[gg]&&EdgeTransitiveGraphQ[gg]&])//Timing

del/.rules

(delall=Select[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&Sort[VertexDegree[gg]]==={2,2,2,2,2,2,2,2,4,4,4,4}&&EdgeTransitiveGraphQ[gg]&])//Timing

K48Subgraph63=EdgeDelete[g,Flatten[del/.rules]]

RecognizeGraph[K48Subgraph63]

VertexDegree[K48Subgraph63]//Sort

EdgeTransitiveGraphQ[K48Subgraph63]

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},12]

Length[etgd]

TextGrid[{#,Cases[GraphData[#,"StandardNames"],{"EdgeTransitive",_}]}&/@etgd,Alignment->Left,Dividers->All]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[12]={
StarGraph[12],
CycleGraph[12],
K48Subgraph42,(*CompleteBipartiteSubgraph[{4,2},{4,8}]*)
K39Subgraph62,(*CompleteBipartiteSubgraph[{6,2},{3,9}]*)
k[2,10],
{
K48Subgraph63,(*CompleteBipartiteSubgraph[{6,3},{4,8}]*)
WreathGraph[6,2],
GraphData["CuboctahedralGraph"]
},
k[3,9],
{EdgeDelete[k[6,6],FindIndependentEdgeSet[k[6,6]]],GraphData["IcosahedralGraph"]},
k[4,8],
k[5,7],
{k[6,6],System`GraphComplement[RookGraph[3,4]]},
EdgeDelete[k[12],UndirectedEdge@@@Flatten[Subsets[#,{2}]&/@Partition[Range[12],4],1]],
EdgeDelete[k[12],UndirectedEdge@@@Flatten[Subsets[#,{2}]&/@Partition[Range[12],3],1]],
EdgeDelete[k[12],FindIndependentEdgeSet[k[12]]],
k[12]
};

et[12]=SplitBy[Sort[{EdgeCount[#],#}&/@ReadEdgeTransitive[12]],First][[All,All,-1]]

Grid[{Union[EdgeCount/@DeleteMissing[#]],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@et[12]),Dividers->All,Alignment->Left]//Quiet

Name fillins

l=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{12,#2[[1]]}}}}&,Flatten[et[12]]],{{},_}]

GraphData["CuboctahedralGraph","Names"]

l=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"12\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[12]]],{{},_}]

13-node (10 graphs)

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},13]

Length[etgd]

TextGrid[Sort[{Cases[GraphData[#,"StandardNames"],{"EdgeTransitive",_}],#}&/@etgd],Alignment->Left,Dividers->All]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[13]={
StarGraph[13],
CycleGraph[13],
k[2,11],
GraphData[{"Cyclotomic",13}],
k[3,10],
k[4,9],
GraphData[{"Paley",13}],
k[5,8],
k[6,7],
k[13]
};

et[13]=SplitBy[Sort[{EdgeCount[#],#}&/@ReadEdgeTransitiveAdjacencyLists[13]],First][[All,All,-1]]

Grid[{Union[EdgeCount/@DeleteMissing[#]],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@et[13]),Dividers->All,Alignment->Left]//Quiet

Names fillin

stdnames=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{13,#2[[1]]}}}}&,Flatten[et[13]]],{{},_}]

names=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"13\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[13]]],{{},_}]

14-node (16 graphs)

(3,3) Subgraph of (Subscript[K, 7,7])==Heawood

CompleteBipartiteSubgraph[{3,3},{7,7}]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(Subscript[K, 7,7])-Heawood

GraphData["HeawoodGraph"]

GraphData["K7,7","Graph","Labeled"]

g=EdgeDelete[GraphData["K7,7"],UndirectedEdge@@@Join[{{1,6},{5,10},{4,13},{3,8},{2,11},{9,14},{7,12}},Partition[Range[14],2,1,1]]]

RecognizeGraph[g]

EdgeTransitiveGraphQ[%]

Missing (Subscript[K, 2,12]), (Subscript[K, 3,11])

2 (4,3) Subgraphs of (Subscript[K, 6,8])

gs=CompleteBipartiteSubgraph[{4,3},{6,8},Infinity];//Timing

g=System`CompleteGraph[{6,8},VertexLabels->"Name"]

VertexDegree[g]

Delete 2 edges from left side:

((Binomial[8,2])^6)

Delete 3 edges from right side:

((Binomial[6,3])^8)

s=Table[Subsets[UndirectedEdge@@Sort[{n,#}]&/@AdjacencyList[g,n],{2}],{n,6}]

s2=Developer`ToPackedArray[s/.Thread[EdgeList[g]->Range[EdgeCount[g]]]];

o=Flatten[Outer[List,Sequence@@s2,1],5];

ByteCount[o]

Length[o]

rules=Thread[Range[EdgeCount[g]]->EdgeList[g]]

degrees=Sort[Join[ConstantArray[4,6],ConstantArray[3,8]]]

(del=SelectFirst[o,Sort[VertexDegree[gg=EdgeDelete[g,Flatten[#/.rules]]]]===degrees&&ConnectedGraphQ[gg]&&EdgeTransitiveGraphQ[gg]&])//Timing

del/.rules

(delall=Select[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&Sort[VertexDegree[gg]]==={2,2,2,2,2,2,2,2,4,4,4,4}&&EdgeTransitiveGraphQ[gg]&])//Timing

CompleteBipartiteSubgraph[{4,3},{6,8}]=EdgeDelete[g,Flatten[del/.rules]]

RecognizeGraph[K48Subgraph63]

VertexDegree[K48Subgraph63]//Sort

EdgeTransitiveGraphQ[K48Subgraph63]

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},14]

Length[etgd]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[14]={
StarGraph[14],
CycleGraph[14],
GraphData["HeawoodGraph"],
{k[2,12],GraphData["RhombicDodecahedralGraph"]},(*,CompleteBipartiteSubgraph[{4,3},{6,8},1|2]}*)
{WreathGraph[7,2],GraphData[{"QuarticTransitive",31}]},
k[3,11],
k[4,10],
EdgeDelete[k[7,7],FindIndependentEdgeSet[k[7,7]]],
k[5,9],
k[6,8],
k[7,7],
EdgeDelete[k[14],FindIndependentEdgeSet[k[14]]],
k[14]
};

Length[Flatten@et[14]]

et[14]=SplitBy[Sort[{EdgeCount[#],#}&/@ReadEdgeTransitiveEdgeLists[14]],First][[All,All,-1]]

Length[Flatten[et[14]]]

Grid[{Union[EdgeCount/@#],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@DeleteCases[et[14],XXX,Infinity]),Dividers->All,Alignment->Left]

Name fillins

stdnames=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{14,#2[[1]]}}}}&,Flatten[et[14]]],{{},_}]

names=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"14\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[14]]],{{},_}]

15-node (25 graphs)

(3,2) Subgraph of (Subscript[K, 6,9])

CompleteBipartiteSubgraph[{3,2},{6,9}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

g=System`CompleteGraph[{6,9},VertexLabels->"Name"]

VertexDegree[g]

Delete 3 edges from left

((Binomial[9,3])^6)

Delete 4 edges from right

((Binomial[6,4])^9)

s=Table[Subsets[UndirectedEdge@@Sort[{n,#}]&/@AdjacencyList[g,n],{1}],{n,5,12}]

s2=Developer`ToPackedArray[s/.Thread[EdgeList[g]->Range[EdgeCount[g]]]]

o=Flatten[Outer[List,Sequence@@s2,1],7];

ByteCount[o]

Length[o]

rules=Thread[Range[EdgeCount[g]]->EdgeList[g]]

degrees=Join[ConstantArray[3,8],ConstantArray[6,4]]

(del=SelectFirst[o,Sort[VertexDegree[gg=EdgeDelete[g,Flatten[#/.rules]]]]===degrees&&ConnectedGraphQ[gg]&&EdgeTransitiveGraphQ[gg]&])//Timing

del/.rules

(delall=Select[o,ConnectedGraphQ[gg=EdgeDelete[g,Flatten[#/.rules]]]&&Sort[VertexDegree[gg]]==={2,2,2,2,2,2,2,2,4,4,4,4}&&EdgeTransitiveGraphQ[gg]&])//Timing

K48Subgraph63=EdgeDelete[g,Flatten[del/.rules]]

RecognizeGraph[K48Subgraph63]

VertexDegree[K48Subgraph63]//Sort

EdgeTransitiveGraphQ[K48Subgraph63]

2 (4,2) Subgraphs of (Subscript[K, 5,10])

CompleteBipartiteSubgraph[{4,2},{5,10}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(8,2) Subgraphs of (Subscript[K, 3,12])

CompleteBipartiteSubgraph[{8,2},{3,12}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(6,3) Subgraphs of (Subscript[K, 5,10])

CompleteBipartiteSubgraph[{6,3},{5,10}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

2 (6,4) Subgraphs of (Subscript[K, 6,9])

CompleteBipartiteSubgraph[{6,4},{6,9}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},15]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

RecognizeGraph[KneserGraph[6,2]]

et[15]={
(*14*) k[1,14],
(*15*) CycleGraph[15],
(*18*) CompleteBipartiteSubgraph[{3,2},{6,9}],
(*20*) {CompleteBipartiteSubgraph[{4,2},{5,10},1],CompleteBipartiteSubgraph[{4,2},{5,10},2]},
(*24*) (*CompleteBipartiteSubgraph[{8,2},{3,12}]*),
(*26*) k[2,13],
(*30*) {CompleteBipartiteSubgraph[{6,3},{5,10}],System`LineGraph[System`PetersenGraph[]],System`CirculantGraph[15,{1,4}]},
(*36*) {k[3,12],CompleteBipartiteSubgraph[{6,4},{6,9},1],CompleteBipartiteSubgraph[{6,4},{6,9},2]},
(*40*) CompleteBipartiteSubgraph[{8,4},{5,10}],
(*44*) k[4,11],
(*45*) {KneserGraph[6,2],System`CirculantGraph[15,{1,4,6}]},
(*50*) k[5,10],
(*54*) k[6,9],
(*56*) k[7,8],
(*60*) {System`GraphComplement[RookGraph[3,5]],System`GraphComplement[KneserGraph[6,2]]},
(*75*) EdgeDelete[k[15],UndirectedEdge@@@Flatten[Subsets[#,{2}]&/@Partition[Range[15],5],1]],
(*90*) EdgeDelete[k[15],UndirectedEdge@@@Flatten[Subsets[#,{2}]&/@Partition[Range[15],3],1]],
(*105*) k[15]
};

etnew=Sort[Cases[ToEntity/@DeleteCases[Flatten@et[15],XXX,Infinity],Entity["Graph",g_]:>g]]

Complement[etgd,etnew]

Complement[etnew,etgd]

Grid[{Union[EdgeCount/@#],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@DeleteCases[et[15],XXX,Infinity]),Dividers->All,Alignment->Left]

Name fillins

l=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{15,#2[[1]]}}}}&,Flatten[et[15]]],{{},_}]

l=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"15\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[15]]],{{},_}]

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},14]

Length[etgd]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[15]={
StarGraph[14],
CycleGraph[14],
GraphData["HeawoodGraph"],
{k[2,12],GraphData["RhombicDodecahedralGraph"]},(*,CompleteBipartiteSubgraph[{4,3},{6,8},1|2]}*)
{WreathGraph[7,2],GraphData[{"QuarticTransitive",31}]},
k[3,11],
k[4,10],
EdgeDelete[k[7,7],FindIndependentEdgeSet[k[7,7]]],
k[5,9],
k[6,8],
k[7,7],
EdgeDelete[k[14],FindIndependentEdgeSet[k[14]]],
k[14]
};

et[15]=SplitBy[Sort[{EdgeCount[#],#}&/@ReadEdgeTransitiveAdjacencyLists[15]],First][[All,All,-1]]

Length[Flatten@et[15]]

Grid[{Union[EdgeCount/@#],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@DeleteCases[et[15],XXX,Infinity]),Dividers->All,Alignment->Left]

Name fillins

stdnames=With[{n=15},DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{n,#2[[1]]}}}}&,Flatten[et[n]]],{{},_}]]

names=With[{n=15},DeleteCases[MapIndexed[{RecognizeGraph[#],{0,ToString[n]<>"\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[n]]],{{},_}]]

16-node (26 graphs)

(3,3) Subgraphs of (Subscript[K, 8,8]) = MoebiusKantor

CompleteBipartiteSubgraph[{3,3},{8,8}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

Through[{VertexCount,EdgeCount,VertexDegree,EdgeTransitiveGraphQ}[GraphData["MoebiusKantorGraph"]]]

2 (6,2) Subgraphs of (Subscript[K, 4,12])

CompleteBipartiteSubgraph[{6,2},{4,12},1,"MaxSize"->2.2*^9][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(5,3) Subgraphs of (Subscript[K, 6,10])

CompleteBipartiteSubgraph[{5,3},{6,10}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(9,3) Subgraphs of (Subscript[K, 4,12])

CompleteBipartiteSubgraph[{9,3},{4,12}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(6,6) Subgraphs of (Subscript[K, 8,8]) = Haar 187

CompleteBipartiteSubgraph[{6,6},{8,8}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(7,7) Subgraphs of (Subscript[K, 8,8]) == 8-crown

CompleteBipartiteSubgraph[{7,7},{8,8}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},16]

Length[etgd]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[16]={
(*15*) StarGraph[16],
(*16*) System`CycleGraph[16],
(*24*){
GraphData["MoebiusKantorGraph"](*CompleteBipartiteSubgraph[{3,3},{8,8}]*),
CompleteBipartiteSubgraph[{6,2},{4,12},1] ,
CompleteBipartiteSubgraph[{6,2},{4,12},2]
},
(*28*) k[2,14],
(*30*) CompleteBipartiteSubgraph[{5,3},{6,10}](* too big *),
(*32*) {HypercubeGraph[4],WreathGraph[8,2]},
(*36*) (*CompleteBipartiteSubgraph[{9,3},{4,12}]*),
(*39*)k[3,13],
(*40*) GraphData["ClebschGraph"],
(*48*){k[4,12],GraphData["ShrikhandeGraph"],RookGraph[4,4],GraphData[{"Haar",187}](*CompleteBipartiteSubgraph[{6,6},{8,8}]*)},
(*55*) k[5,11],
(*56*)CrownGraph[8],(*CompleteBipartiteSubgraph[{7,7},{8,8}]*),
(*60*) k[6,10],
(*63*) k[7,9],
(*64*) k[8,8],
(*72*)EdgeDelete[k[16],UndirectedEdge@@@Flatten[Subsets[#,{2}]&/@Partition[Range[16],4],1]],
(*80*) System`GraphComplement[GraphData["ClebschGraph"]],
(*96*)System`GraphComplement[RookGraph[4,4]],
(*112*)EdgeDelete[k[16],FindIndependentEdgeSet[k[16]]],
(*120*) k[16]
};

et[16]=SplitBy[Sort[{EdgeCount[#],#}&/@ReadEdgeTransitiveAdjacencyLists[16]],First][[All,All,-1]]

Length[Flatten@et[16]]

Grid[{Sort[EdgeCount/@#],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@DeleteCases[et[16],XXX,Infinity]),Dividers->All,Alignment->Left]

Name fillins

names=With[{n=16},DeleteCases[MapIndexed[{RecognizeGraph[#],{0,ToString[n]<>"\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[n]]],{{},_}]]

stdnames=With[{n=16},DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{n,#2[[1]]}}}}&,Flatten[et[n]]],{{},_}]]

17-node (12 graphs)

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},17]

Length[etgd]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[17]={
StarGraph[17],
System`CycleGraph[17],
k[2,15],
System`CirculantGraph[17,{1,4}],
k[3,14],
k[4,13],
k[5,12],
k[6,11],
PaleyGraph[17],
k[7,10],
k[8,9],
k[17]
};

et[17]=SplitBy[Sort[{EdgeCount[#],#}&/@ReadEdgeTransitiveAdjacencyLists[17]],First][[All,All,-1]]

Length[Flatten@et[17]]

Grid[{Union[EdgeCount/@#],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@DeleteCases[et[17],XXX,Infinity]),Dividers->All,Alignment->Left]

Name fillins

names=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"17\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[17]]],{{},_}]

stdnames=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{17,#2[[1]]}}}}&,Flatten[et[17]]],{{},_}]

18-node (28 graphs)

2 (4,2) Subgraphs of (Subscript[K, 6,12])

CompleteBipartiteSubgraph[{4,2},{6,12}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(3,3) Subgraph of (Subscript[K, 9,9])==Pappus

CompleteBipartiteSubgraph[{3,3},{9,9}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(10,2) Subgraph of (Subscript[K, 3,15])

CompleteBipartiteSubgraph[{10,2},{3,15}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(6,3) Subgraph of (Subscript[K, 6,12])

CompleteBipartiteSubgraph[{6,3},{6,12}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

(4,4) Subgraph of (Subscript[K, 9,9])==Qt66

CompleteBipartiteSubgraph[{4,4},{9,9}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

GraphData["Qt66"]//VertexDegree

(8,4) Subgraph of (Subscript[K, 6,12])

CompleteBipartiteSubgraph[{8,4},{6,12}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

2 (6,6) Subgraphs of (Subscript[K, 9,9]) (one is (Subscript[Ci, 18])(1,5,7)

CompleteBipartiteSubgraph[{6,6},{9,9}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

VertexDegree[System`CirculantGraph[18,{1,5,7}]]

(10,5) Subgraph of (Subscript[K, 6,12])

CompleteBipartiteSubgraph[{10,5},{6,12}][[1]]

Through[{EdgeCount,VertexDegree,ToEntity,EdgeTransitiveGraphQ}[%]]

Complement of (Subscript[K, 6])×(Subscript[K, 3])

VertexDegree[System`GraphComplement[RookGraph[6,3]]]

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},18]

Length[etgd]

EdgeCount[et18extra]

GraphData[{"RookComplement",{2,9}},"EdgeCount"]

GraphData[{"RookComplement",{2,9}},"StandardNames"]

GraphData[{"CompleteBipartite",{6,12}},"Classes"]

RecognizeGraph@EdgeDelete[k[9,9],FindIndependentEdgeSet[k[9,9]]]

GraphData[{"Crown",9},"EdgeCount"]

GraphData[{"CocktailParty",6},"V"]

GraphData[{"CocktailParty",6},"Classes"]

Grid[{#[[1,1]],Length[#[[All,2]]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Decimal,Left}}]

et[18]={
(*17*) StarGraph[18],
(*18*) CycleGraph[18],
(*24*){CompleteBipartiteSubgraph[{4,2},{6,12},1],CompleteBipartiteSubgraph[{4,2},{6,12},2]},
(*27*)GraphData["PappusGraph"](*CompleteBipartiteSubgraph[{3,3},{9,9}]*),
(*30*)  (*CompleteBipartiteSubgraph[{10,2},{3,15}]*),
(*32*)k[2,16],
(*36*){CompleteBipartiteSubgraph[{6,3},{6,12}],GraphData["Qt66"],System`CirculantGraph[18,{1,8}]},
(*45*) k[3,15],
(*48*) CompleteBipartiteSubgraph[{8,4},{6,12}],
(*54*) {
System`CirculantGraph[18,{1,5,7}](*CompleteBipartiteSubgraph[{6,6},{9,9},1]*),
CompleteBipartiteSubgraph[{6,6},{9,9},2]
},
(*56*) k[4,14],
(*60*)CompleteBipartiteSubgraph[{10,5},{6,12}],
(*65*) k[5,13],
(*72*) {EdgeDelete[k[9,9],FindIndependentEdgeSet[k[9,9]]],System`GraphComplement[RookGraph[9,2]],k[6,12]},
	(*** XXX first two above are the same!!! ***)
(*77*) k[7,11],
(*80*) k[8,10],
(*81*) k[9,9],
(*90*)System`GraphComplement[RookGraph[6,3]],
(*108*)k[6,6,6],
(*135*)k[3,3,3,3,3,3],
(*144*) EdgeDelete[k[18],FindIndependentEdgeSet[k[18]]],
(*153*)k[18]
};

et[18,1]=Most@Module[{string=StringReplace[Import["~/Documents/Mathematica/Paclets/GraphData/Collections/EdgeTransitive/18 et graphs-adjacencylists.rtf","String"],{"}"->"","\\\n"->""}]},MyFromAdjacencyLists/@(StringReplace[Most[StringSplit[StringTrim[#],";"]],RegularExpression[" *\\d+ : (.+)"]:>(StringSplit["$1"])]&/@(StringSplit[#,"\n\n"][[1]]&/@Rest[StringSplit[string,"\\b0"]])/.StringExpression[l_]:>(1+ToExpression[l]))
]

et[18,2]=Most@ReadEdgeTransitiveEdgeLists[18,"18 et graphs-edgelists.rtf"]

et[18,3]={IndexGraph@System`Graph[{0<->1,0<->2,0<->3,0<->4,0<->5,0<->6,0<->7,0<->8,1<->2,1<->3,1<->9,1<->10,1<->11,1<->12,1<->13,2<->4,2<->9,2<->14,2<->15,2<->16,2<->17,3<->4,3<->9,3<->14,3<->15,3<->16,3<->17,4<->9,4<->10,4<->11,4<->12,4<->13,5<->6,5<->7,5<->9,5<->10,5<->11,5<->14,5<->15,6<->8,6<->9,6<->12,6<->13,6<->16,6<->17,7<->8,7<->9,7<->12,7<->13,7<->16,7<->17,8<->9,8<->10,8<->11,8<->14,8<->15,10<->12,10<->13,10<->14,10<->15,11<->12,11<->13,11<->14,11<->15,12<->16,12<->17,13<->16,13<->17,14<->16,14<->17,15<->16,15<->17}]}

ets=Join@@Table[et[18,i],{i,3}]

et18withoutdups=#[[All,2]][[1]]&/@SplitBy[SortBy[{CanonicalForm[#],#}&/@ets,First],First]

et[18]=SplitBy[Sort[{EdgeCount[#],#}&/@et18withoutdups],First][[All,All,2]]

Length[Flatten[et[18],1]]

Grid[{Union[EdgeCount/@#],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@et[18]),Dividers->All,Alignment->Left]

Name fillins

stdnames=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{18,#2[[1]]}}}}&,Flatten[et[18]]],{{},_}]

names=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"18\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[18]]],{{},_}]

19-node (12 graphs)

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},19]

Length[etgd]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

et[19]={
StarGraph[19],
System`CycleGraph[19],
k[2,17],
k[3,16],
CyclotomicGraph[19],
k[4,15],
k[5,14],
k[6,13],
k[7,12],
k[8,11],
k[9,10],
k[19]
};

et[19]=SplitBy[Sort[{EdgeCount[#],#}&/@ReadEdgeTransitiveEdgeLists[19]],First][[All,All,-1]]

Length[Flatten@et[19]]

Grid[{Union[EdgeCount/@#],ToEntity/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@et[19]),Dividers->All,Alignment->Left]

Name fillins

names=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"19\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[19]]],{{},_}]

stdnames=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{19,#2[[1]]}}}}&,Flatten[et[19]]],{{},_}]

20-node (43 graphs)

Unnamed

G1=System`Graph[{0<->1,0<->2,0<->3,0<->4,1<->5,1<->7,1<->8,2<->6,2<->9,2<->10,3<->6,3<->11,3<->12,4<->5,4<->13,4<->14,5<->18,5<->19,6<->16,6<->17,7<->9,7<->11,7<->16,8<->10,8<->12,8<->16,9<->14,9<->18,10<->13,10<->18,11<->14,11<->19,12<->13,12<->19,13<->17,14<->17,15<->16,15<->17,15<->18,15<->19}];
G2=System`Graph[{0<->1,0<->2,0<->3,0<->4,0<->5,0<->6,1<->7,1<->8,1<->9,1<->10,1<->11,2<->7,2<->8,2<->9,2<->10,2<->11,3<->7,3<->12,3<->13,3<->14,3<->15,4<->7,4<->12,4<->13,4<->14,4<->15,5<->7,5<->16,5<->17,5<->18,5<->19,6<->7,6<->16,6<->17,6<->18,6<->19,8<->12,8<->13,8<->16,8<->17,9<->12,9<->13,9<->16,9<->17,10<->14,10<->15,10<->18,10<->19,11<->14,11<->15,11<->18,11<->19,12<->18,12<->19,13<->18,13<->19,14<->16,14<->17,15<->16,15<->17}];
G3=System`Graph[{0<->1,0<->2,0<->3,0<->4,0<->5,0<->6,1<->2,1<->7,1<->8,1<->13,1<->14,2<->9,2<->10,2<->15,2<->16,3<->5,3<->7,3<->12,3<->15,3<->17,4<->6,4<->8,4<->12,4<->16,4<->18,5<->10,5<->11,5<->14,5<->18,6<->9,6<->11,6<->13,6<->17,7<->10,7<->13,7<->17,7<->19,8<->9,8<->14,8<->18,8<->19,9<->15,9<->17,9<->19,10<->16,10<->18,10<->19,11<->12,11<->13,11<->14,11<->19,12<->15,12<->16,12<->19,13<->15,13<->18,14<->16,14<->17,15<->18,16<->17}];
G4=System`Graph[{0<->1,0<->2,0<->3,0<->4,0<->5,0<->6,1<->2,1<->13,1<->3,1<->7,1<->8,2<->3,2<->9,2<->11,2<->14,3<->10,3<->12,3<->15,4<->5,4<->6,4<->7,4<->10,4<->16,5<->6,5<->8,5<->9,5<->17,6<->11,6<->12,6<->18,7<->8,7<->10,7<->13,7<->16,8<->9,8<->13,8<->17,9<->11,9<->14,9<->17,10<->12,10<->15,10<->16,11<->12,11<->14,11<->18,12<->15,12<->18,13<->14,13<->15,13<->19,14<->15,14<->19,15<->19,16<->17,16<->18,16<->19,17<->18,17<->19,18<->19}];
G5=System`Graph[{0<->1,0<->2,0<->3,0<->4,0<->5,0<->6,0<->7,0<->8,0<->9,1<->2,1<->3,1<->4,1<->5,1<->10,1<->11,1<->12,1<->13,2<->3,2<->6,2<->7,2<->10,2<->11,2<->14,2<->15,3<->8,3<->9,3<->12,3<->13,3<->14,3<->15,4<->5,4<->6,4<->8,4<->10,4<->12,4<->16,4<->17,5<->7,5<->9,5<->11,5<->13,5<->16,5<->17,6<->7,6<->8,6<->10,6<->15,6<->16,6<->18,7<->9,7<->11,7<->14,7<->16,7<->18,8<->9,8<->12,8<->15,8<->17,8<->18,9<->13,9<->14,9<->17,9<->18,10<->11,10<->12,10<->15,10<->16,10<->19,11<->13,11<->14,11<->16,11<->19,12<->13,12<->15,12<->17,12<->19,13<->14,13<->17,13<->19,14<->15,14<->18,14<->19,15<->18,15<->19,16<->17,16<->18,16<->19,17<->18,17<->19,18<->19}];
G6=System`Graph[{0<->1,0<->2,0<->3,0<->4,0<->5,0<->6,0<->7,0<->8,0<->9,0<->10,0<->11,0<->12,1<->2,1<->3,1<->4,1<->5,1<->6,1<->7,1<->13,1<->14,1<->15,1<->16,1<->17,2<->3,2<->4,2<->8,2<->9,2<->10,2<->13,2<->14,2<->15,2<->18,2<->19,3<->5,3<->8,3<->11,3<->13,3<->16,3<->17,3<->18,3<->19,3<->12,4<->5,4<->8,4<->11,4<->12,4<->13,4<->16,4<->17,4<->18,4<->19,5<->8,5<->9,5<->10,5<->13,5<->14,5<->15,5<->18,5<->19,6<->8,6<->9,6<->10,6<->11,6<->12,6<->13,6<->14,6<->15,6<->16,6<->17,7<->8,7<->9,7<->10,7<->11,7<->12,7<->13,7<->14,7<->15,7<->16,7<->17,8<->13,8<->14,8<->15,8<->16,8<->17,9<->11,9<->12,9<->13,9<->14,9<->15,9<->18,9<->19,10<->11,10<->12,10<->13,10<->14,10<->15,10<->18,10<->19,11<->13,11<->16,11<->17,11<->18,11<->19,12<->13,12<->16,12<->17,12<->18,12<->19,14<->16,14<->17,14<->18,14<->19,15<->16,15<->17,15<->18,15<->19,16<->18,16<->19,17<->18,17<->19}];

RecognizeGraph/@{G1,G2,G3,G4,G5,G6}

Table

etgd=Sort@GraphData[{"Connected","EdgeTransitive"},20]

Length[etgd]

Grid[{#[[1,1]],#[[All,2]]}&/@SplitBy[Sort[GraphData[#,{"M","#"}]&/@etgd],First],Dividers->All,Alignment->{{Decimal,Left}}]

ReadEdgeTransitiveAdjacencyLists[20,"20 et graphs.txt"]

et20withdups=Join[
ReadEdgeTransitiveAdjacencyLists[20,"20 et graphs.txt"],
{
k[1,19],
k[2,18],
k[3,17],
k[4,16],
k[5,15],
k[6,14],
k[7,13],
k[8,12],
k[9,11],
k[10,10]
}
]

et20withoutdups=SplitBy[SortBy[{CanonicalForm[#],#}&/@et20withdups,First],First][[All,All,2]][[All,1]]

Length[et20withoutdups]

et[20]=SplitBy[Sort[{EdgeCount[#],#}&/@et20withoutdups],First][[All,All,2]]

VertexCount/@Flatten[et[20]]

Length[Flatten@et[20]]

Grid[{Union[EdgeCount/@#],RecognizeGraph/@#,EdgeTransitiveGraphQ/@#}&/@(Flatten[{#}]&/@et[20]),Dividers->All,Alignment->Left]

Name fillins

names=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,"20\[Hyphen]edge transitive graph "<>ToString[#2[[1]]]}}&,Flatten[et[20]]],{{}|{"EdgeTransitive",_},_}]

stdnames=DeleteCases[MapIndexed[{RecognizeGraph[#],{0,{"EdgeTransitive",{20,#2[[1]]}}}}&,Flatten[et[20]]],{{}|{"EdgeTransitive",_},_}]

Databases

Connected up to 20 nodes from private correspondence [used for {"EdgeTransitive", {n _}} for n <= 20]

SetDirectory["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/EdgeTransitive"]

FileNames["*"]

Connected up to 47 nodes from Condor [used for {"EdgeTransitive", {n _}} for n > 20]

https://www.math.auckland.ac.nz/~conder/AllSmallETgraphs-upto47-summary.txt

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

etedges=StringCases[data,"EdgePairs["~~n:DigitCharacter..~~"]["~~i:DigitCharacter..~~"]:="~~Shortest[edges__]~~";":>ToExpression[{{n,i},edges}]]

A095424

counts=Length/@(etedgesbyvertexcount=SplitBy[etedges,#[[1,1]]&])

counts[[21;;]]

Total[%]

Too many to add to GraphData

Write out as separate files with edge lists for each VertexCount

SetDirectory["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/Condor/ConnectedEdgeTransitive"]

Put[#[[All,2]],ToString[#[[1,1,1]]]<>".txt"]&/@etedgesbyvertexcount;

files=SortBy[FileNames["*.txt"],ToExpression[FileBaseName[#]]&]

Monitor[And@@@(Function[file,Map[EdgeTransitiveGraphQ[System`Graph[UndirectedEdge@@@#]]&,Get[f=file],{1}]]/@files),f]

And@@%

By vertex count

SetDirectory["/Users/eww/Documents/Mathematica/Paclets/GraphData/Collections/Condor/ConnectedEdgeTransitive"]

files=SortBy[FileNames["*.txt"],ToExpression[FileBaseName[#]]&]

Length/@(et=MapIndexed[{#,RecognizeGraph@#,{"EdgeTransitive",#2}}&,(Graph[UndirectedEdge@@@#]&/@Get[#])&/@files,{2}])

new=Select[GraphData[{"EdgeTransitive","Connected"}],MissingQ[FirstCase[GraphData[#,"StandardNames"],{"EdgeTransitive",_}]]&];

Union[GraphData[#,"V"]&/@new]

Do not use Condor indexing for graphs on n <= 20 which will have different AlternateStandardNames based on private correspondence before the Condor reference was known

altstdnames=Select[
DeleteCases[Flatten[et,1],{_,{},_}],
VertexCount[#[[1]]]>20&&FreeQ[GraphData[#[[2]],"StandardNames"],#[[3]]]&
]

l={#2,{0,SortBy[Union@Append[GraphData[#2,"AlternateStandardNames"],#3],First[Flatten[{#}]]&]}}&@@@altstdnames

PropertyReplace[l,"AlternateStandardNames","14.1"]

RenameGraphFiles[]

l2={#2,{0,Union[GraphData[#2,"AlternateNames"],{ToString[#3[[2,1]]]<>"\[Hyphen]edge transitive graph "<>ToString[#3[[2,2]]]}]}}&@@@altstdnames

PropertyReplace[l2,"AlternateNames","14.1"]

RenameGraphFiles[]

l3={#2,{0,Union[Append[DeleteCases[GraphData[#2,"NotationRules"],HoldPattern[Rule["EdgeTransitive",_]]],Rule@@#3]]}}&@@@altstdnames

use Condor indexing even for graphs on n <= 20 which will have different AlternateStandardNames based on private correspondence before the Condor reference was known

PropertyReplace[l3,"NotationRules","14.1"]

RenameGraphFiles[]

Embeddings

<<MathWorld`Graphs`

8

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 8]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 8],{"EdgeTransitive",_}]],Dividers->All]

9

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 9]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 9],{"EdgeTransitive",_}]],Dividers->All]

{"EdgeTransitive", {9, 3}} == {"CompleteBipartite", {2, 7}}

Names

GraphData[{"EdgeTransitive",{9,3}},"StandardName"]

GraphData[{"EdgeTransitive",{9,3}},"StandardNames"]

{"EdgeTransitive", {9, 4}} == {"CompleteBipartite", {4, 5}}

Names

GraphData[{"EdgeTransitive",{9,4}},"StandardName"]

GraphData[{"EdgeTransitive",{9,4}},"StandardNames"]

{"EdgeTransitive", {9, 5}} == {"CompleteBipartite", {3, 6}}

Names

GraphData[{"EdgeTransitive",{9,5}},"StandardName"]

GraphData[{"EdgeTransitive",{9,5}},"StandardNames"]

{"EdgeTransitive", {9, 6}} == {"CompleteTripartite", {3, 3, 3}}

Names

GraphData[{"EdgeTransitive",{9,6}},"StandardName"]

GraphData[{"EdgeTransitive",{9,6}},"StandardNames"]

{"EdgeTransitive", {9, 7}} == {"Cycle", 9}

Names

GraphData[{"EdgeTransitive",{9,7}},"StandardName"]

GraphData[{"EdgeTransitive",{9,7}},"StandardNames"]

{"EdgeTransitive", {9, 9}} == {"GeneralizedQuadrangle", {2, 1}}

Names

GraphData[{"EdgeTransitive",{9,9}},"StandardName"]

GraphData[{"EdgeTransitive",{9,9}},"StandardNames"]

{"EdgeTransitive", {9, 11}} == {"Star", 9}

Names

GraphData[{"EdgeTransitive",{9,11}},"StandardName"]

GraphData[{"EdgeTransitive",{9,11}},"StandardNames"]

{"EdgeTransitive", {9, 14}} [planar, L(•) == Qt19]

Names

GraphData[{"EdgeTransitive",{9,14}},"Classes"]

GraphData[{"EdgeTransitive",{9,14}},"StandardName"]

GraphData[{"EdgeTransitive",{9,14}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{9,14}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{9,14}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{9,14}},"Edges"]

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

RecognizeGraph[g]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

p=GraphEmbedding[GraphData[g]]

p2=Mean/@Partition[p[[{5,6,4}]],2,1,1]

pnew=ReplacePart[p,{9->p2[[1]],7->p2[[2]],8->p2[[3]]}]

System`Graph[Range[9],GraphData[g,"EdgeList"],VertexCoordinates->pnew]

Degenerate

GraphData[{"EdgeTransitive",{9,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{9,14}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{9,14}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{9,14}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{9,14}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{9,14}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{9,14}},"Planar"]

GraphData[{"EdgeTransitive",{9,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{9,14}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{9,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{9,14}}],"CrossingNumber"->cn])//PolyhedralGraphQ

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{9,14}}],"CrossingNumber"->cn,RandomSeed->i],{i,100}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{9,14}},"Circulant"]

GraphData[{"EdgeTransitive",{9,14}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{9,14}},"ComplementGraph","Name"]

GraphComplement/@GraphData[%,"Graph","All"]

Line graph

GraphData[{"EdgeTransitive",{9,14}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{9,14}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{9,14}}&]

RootGraph[GraphData[{"EdgeTransitive",{9,14}}]]

Halin

GraphData[{"EdgeTransitive",{9,14}},"Halin"]

GraphData[{"EdgeTransitive",{9,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{9,14}},"Rigid"]

GraphData[{"EdgeTransitive",{9,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{9,14}},"Flexible"]

GraphData[{"EdgeTransitive",{9,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{9,14}},"LCF"]

GraphData[{"EdgeTransitive",{9,14}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{9,14}},"LCFSignature"]

GraphData[{"EdgeTransitive",{9,14}},"LCFNotations"]

GraphData[{"EdgeTransitive",{9,14}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{9,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{9,14}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{9,14}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance construction

v0=GraphEmbedding[CenterGraph@]

aa=Mean[Norm[v0[[#]]]&/@{8,9,1}]

bb=Mean[Norm[v0[[#]]]&/@{3,7,2}]

cc=Mean[Norm[v0[[#]]]&/@{4,5,6}]

cs[x_]:=Through[{Cos,Sin}[x]]

v={a cs[(π/2)-((2π)/3)],{0,-b},b cs[-(π/2)+((2π)/3)],c cs[-(π/2)+((2π)/3)],c cs[-(π/2)-((2π)/3)],{0,-c},b cs[-(π/2)-((2π)/3)],{0,a},a cs[(π/2)+((2π)/3)]};
ee=GraphData[{"EdgeTransitive",{9,14}},"Edges"];
eqn=UnitEdgeEquations[v,ee]//FullSimplify//Union

g0=Graph[Range[9],ee,VertexCoordinates->(v/.{a->aa,b->bb,c->cc}),VertexLabels->Automatic]

EdgeLengths[g0]

soln=Solve[eqn,{a,b,c},Reals]//FullSimplify//Union

N[(2/(Sqrt[3]))]

Manipulate[Graph[Range[9],ee,VertexCoordinates->(v/.soln[[1]]/.a->aa)],{aa,-1.2,1.2}]

Table[Graph[Range[9],ee,VertexCoordinates->(v/.soln[[1]]/.a->aa)],{aa,-1.2,1.2,.1}]

g=Graph[Range[9],ee,VertexCoordinates->(v/.soln[[1]]/.a->-2/3)]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{9,14}},"VertexList"],GraphData[{"EdgeTransitive",{9,14}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{9,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"EdgeTransitive",{9,14}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{9,14}}],TimeConstraint->300,"Results"->All]//Timing}

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

gs={,CenterGraph@RotateGraph[,{1,8}],CenterGraph@RotateGraph[,{9,1}],RotateGraph[,{41,28}]}

Matchstick

GraphData[{"EdgeTransitive",{9,14}},"Matchstick"]

GraphData[{"EdgeTransitive",{9,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{9,14}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{9,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{9,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{9,14}},"Polyhedral"]

GraphData[{"EdgeTransitive",{9,14}},"Graph",{"3D","Polyhedron"}]

10

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 10]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 10],{"EdgeTransitive",_}]],Dividers->All]

11

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 11]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 11],{"EdgeTransitive",_}]],Dividers->All]

12

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 12]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 12],{"EdgeTransitive",_}]],Dividers->All]

{"EdgeTransitive", {12, 3}} [planar, L(•) = Qt50]

Names

GraphData[{"EdgeTransitive",{12,3}},"StandardName"]

GraphData[{"EdgeTransitive",{12,3}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{12,3}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{12,3}},"Edges"]

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

RecognizeGraph[g]

g=GraphData[gn,"Graph","Labeled"]

EdgeCount[g]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

v=GraphData[gn,"VertexCoordinates"]

p=With[{a=1/2},Sqrt[2]ReplacePart[v,{9->a{1,1},10->a{-1,1},11->-a{1,1},12->a{1,-1}}]]

g=System`Graph[Range[12],EdgeList[g],VertexCoordinates->p,VertexLabels->"Name"]

m=Mean/@{p[[{6,7}]],p[[{6,5}]],p[[{5,8}]],p[[{7,8}]]}

p2=ReplacePart[p,{3->m[[1]],4->m[[4]],1->m[[3]],2->m[[2]]}]

System`Graph[Range[12],EdgeList[g],VertexCoordinates->p2,VertexLabels->"Name"]

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{12,3}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{12,3}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{12,3}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{12,3}},{"RCN","CN"}]

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

MinimalCrossing construction

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{12,3}}],"CrossingNumber"->cn])//PolyhedralGraphQ

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

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

v=Join[CirclePoints[{1,-Pi/2},8]];
v=Join[v,Mean/@Partition[v[[{2,4,6,8}]],2,1,1]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,8},1],e[2,9,4,10,6,11,8,12,2]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{12,3}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{12,3}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{12,3}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{12,3}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{12,3}}&]

RootGraph[GraphData[{"EdgeTransitive",{12,3}}]]

Halin

GraphData[{"EdgeTransitive",{12,3}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{12,3}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{12,3}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{12,3}},"LCF"]

GraphData[{"EdgeTransitive",{12,3}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{12,3}},"LCFSignature"]

GraphData[{"EdgeTransitive",{12,3}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{12,3}},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

gs=CenterGraph/@{RotateGraph[LabelGraph@,{10,3}],}

Matchstick

GraphData[{"EdgeTransitive",{12,3}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{12,3}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{12,3}},"Polyhedral"]

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

{"EdgeTransitive", {12, 4}} [planar]

Names

GraphData[{"EdgeTransitive",{12,4}},"StandardName"]

GraphData[{"EdgeTransitive",{12,4}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{12,4}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{12,4}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{12,4}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{12,4}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{12,4}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{12,4}},{"RCN","CN"}]

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

MinimalCrossing construction

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{12,4}}],"CrossingNumber"->cn])//PolyhedralGraphQ

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{12,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[{"EdgeTransitive",{12,4}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{12,4}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{12,4}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{12,4}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{12,4}}&]

RootGraph[GraphData[{"EdgeTransitive",{12,4}}]]

Halin

GraphData[{"EdgeTransitive",{12,4}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{12,4}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{12,4}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{12,4}},"LCF"]

GraphData[{"EdgeTransitive",{12,4}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{12,4}},"LCFSignature"]

GraphData[{"EdgeTransitive",{12,4}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{12,4}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"EdgeTransitive",{12,4}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{12,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{12,4}},"Polyhedral"]

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

{"EdgeTransitive", {12, 6}}

Names

GraphData[{"EdgeTransitive",{12,6}},"StandardName"]

GraphData[{"EdgeTransitive",{12,6}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{12,6}},"EdgeList"]]

Default embedding

GraphPlot@RotateGraph[Graph@GraphData[{"EdgeTransitive",{12,6}},"Edges"],Pi/2]

RotateGraph[GraphicsToGraph@,Pi]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{12,6}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{12,6}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{12,6}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{12,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{12,6}}],"CrossingNumber"->cn,RandomSeed->i],{i,500}]//Union

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@MinimalCrossingGraph[GraphData[{"EdgeTransitive",{12,6}}],"CrossingNumber"->4,RandomSeed->1111]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{12,6}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{12,6}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{12,6}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{12,6}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{12,6}}&]

RootGraph[GraphData[{"EdgeTransitive",{12,6}}]]

Halin

GraphData[{"EdgeTransitive",{12,6}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{12,6}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{12,6}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{12,6}},"LCF"]

GraphData[{"EdgeTransitive",{12,6}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{12,6}},"LCFSignature"]

GraphData[{"EdgeTransitive",{12,6}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{12,6}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"EdgeTransitive",{12,6}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{12,6}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{12,6}},"Polyhedral"]

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

13

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 13]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 13],{"EdgeTransitive",_}]],Dividers->All]

14

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 14]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 14],{"EdgeTransitive",_}]],Dividers->All]

{"EdgeTransitive", {14, 5}}

Names

GraphData[{"EdgeTransitive",{14,5}},"StandardName"]

GraphData[{"EdgeTransitive",{14,5}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{14,5}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{14,5}},"Edges"]

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

RecognizeGraph[g]

g=GraphPlot@GraphData[{"EdgeTransitive",{14,5}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{14,5}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{14,5}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{14,5}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{14,5}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{14,5}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@RotateGraph[HighlightGraph[GraphicsToGraph@,{15,16,17,18}],{8,4}]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{14,5}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{14,5}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{14,5}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{14,5}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{14,5}}&]

RootGraph[GraphData[{"EdgeTransitive",{14,5}}]]

Halin

GraphData[{"EdgeTransitive",{14,5}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{14,5}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{14,5}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{14,5}},"LCF"]

GraphData[{"EdgeTransitive",{14,5}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{14,5}},"LCFSignature"]

GraphData[{"EdgeTransitive",{14,5}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{14,5}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"EdgeTransitive",{14,5}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{14,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{14,5}},"Polyhedral"]

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

15

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 15]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 15],{"EdgeTransitive",_}]],Dividers->All]

{"EdgeTransitive", {15, 1}} == {"Star", 15}

Names

GraphData[{"EdgeTransitive",{15,1}},"StandardName"]

GraphData[{"EdgeTransitive",{15,1}},"StandardNames"]

{"EdgeTransitive", {15, 2}} == {"Cycle", 15}

Names

GraphData[{"EdgeTransitive",{15,2}},"StandardName"]

GraphData[{"EdgeTransitive",{15,2}},"StandardNames"]

{"EdgeTransitive", {15, 3}}

Names

GraphData[{"EdgeTransitive",{15,3}},"StandardName"]

GraphData[{"EdgeTransitive",{15,3}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,3}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{15,3}},"Edges"]

v=CirclePoints[{1,-Pi/2},12];
v=Join[v,v[[#]]+(v[[#2]]-v[[#1]])3/4&@@@{{3,9},{1,7},{11,5}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,12},1,14,7],e[9,13,3],e[11,15,5]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

g=GraphData[gn,"Graph","Labeled"]

Through[{VertexCount,EdgeCount}[g]]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

GraphEmbedding[g]

v=(#-{1.6379475022815584`,1.4878074969561095`})&/@GraphEmbedding[g]

System`Graph[Range[14],EdgeList[g],VertexCoordinates->(vnew=ReplacePart[v,{8->{-2,2},13->{0,2},2->{2,2},11->{-2,1},12->{2,1},5->{-2,-2},7->{2,-2},14->{-2,-1},10->{2,-1},9->{-2,0},6->{2,0},15->{0,-2},4->{0,1},1->{1,-(1/2)},3->{-1,-1/2}}]),VertexLabels->"Name"]

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{15,3}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{15,3}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{15,3}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{15,3}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,3}}],"CrossingNumber"->cn])//PolyhedralGraphQ

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

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

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@

v=Join[CirclePoints[{1,-Pi/2},8],CirclePoints[1/4,4]];
v=Join[v,Mean[v[[#]]]&/@{{6,11},{4,10},{10,11}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,8},1],e[8,9,10,15,11,12,2],e[6,13,11],e[10,14,4]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

gs=UnlabelGraph/@{,}

Circulant

GraphData[{"EdgeTransitive",{15,3}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{15,3}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,3}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,3}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,3}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,3}}]]

Halin

GraphData[{"EdgeTransitive",{15,3}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{15,3}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{15,3}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{15,3}},"LCF"]

GraphData[{"EdgeTransitive",{15,3}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,3}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,3}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{15,3}},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

gs={,,RotateGraph[,-Pi/2],RotateGraph[,{23,1}],,,,};

Matchstick

GraphData[{"EdgeTransitive",{15,3}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,3}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{15,3}},"Polyhedral"]

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

{"EdgeTransitive", {15, 4}} [L(•) == PS(5, 2)]

Names

GraphData[{"EdgeTransitive",{15,4}},"StandardName"]

GraphData[{"EdgeTransitive",{15,4}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,4}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{15,4}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{15,4}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{15,4}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{15,4}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{15,4}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,4}}],"CrossingNumber"->cn,RandomSeed->i],{i,500}]//Union

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

gs=UnlabelGraph/@{,}

Circulant

GraphData[{"EdgeTransitive",{15,4}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{15,4}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,4}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,4}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,4}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,4}}]]

Halin

GraphData[{"EdgeTransitive",{15,4}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{15,4}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{15,4}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{15,4}},"LCF"]

GraphData[{"EdgeTransitive",{15,4}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,4}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,4}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{15,4}},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

gs={,};

Matchstick

GraphData[{"EdgeTransitive",{15,4}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{15,4}},"Polyhedral"]

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

{"EdgeTransitive", {15, 5}} [planar]

Names

GraphData[{"EdgeTransitive",{15,5}},"StandardName"]

GraphData[{"EdgeTransitive",{15,5}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,5}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{15,5}},"Edges"]

v=Join[p=CirclePoints[5],Mean/@Partition[p,2,1,1]];
v=Join[v,Mean[v[[#]]]&/@Partition[Range[6,10],2,1,1]];
g=Graph[Range[Length[v]],Sort[Sort/@Join[
Partition[{4,9,5,10,1,6,2,7,3,8},2,1,1],
Partition[{10,15,6,11,7,12,8,13,9,14},2,1,1]
]],VertexCoordinates->v,VertexLabels->"Name"]

RecognizeGraph[g]

Decagon in pentagon

(v[[#]]*=((Norm[v[[10]]])/(Norm[v[[15]]]))//FullSimplify)&/@Range[11,15]

g=Graph[Range[Length[v]],EdgeList[g],VertexCoordinates->v,VertexLabels->Automatic]

Norm[v[[1]]]-Norm@Mean[v[[{2,10}]]]//FullSimplify

v=CirclePoints[{1,-Pi/2},10];
v=Join[v,Table[v[[i]]-(1/2) (3-(Sqrt[5]))Normalize[v[[i]]],{i,1,9,2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,5,6,7,8,9,10,1],e[10,11,2,12,4,13,6,14,8,15,10]},VertexCoordinates->v,VertexLabels->"Name"]

v=CirclePoints[{1,Pi/2},10];
v=Join[v,Mean[v[[#]]]&/@Partition[Range[1,9,2],2,1,1]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,10},1,11,3,12,5,13,7,14,9,15,1]},VertexCoordinates->v,VertexLabels->"Name"]

Star in decagon

v=Join[p=CirclePoints[5],Mean/@Partition[p,2,1,1]];
v=Join[v,Mean[v[[#]]]&/@Partition[Range[6,10],2,1,1]];
Table[v[[i]]=v[[i]]+(v[[i]]-v[[If[i==15,1,i-9]]]),{i,11,15}];
g=Graph[Range[Length[v]],Sort[Sort/@Join[
Partition[{4,9,5,10,1,6,2,7,3,8},2,1,1],
Partition[{10,15,6,11,7,12,8,13,9,14},2,1,1]
]],VertexCoordinates->v,VertexLabels->"Name"]

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

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{15,5}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{15,5}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{15,5}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{15,5}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,5}}],"CrossingNumber"->cn])//PolyhedralGraphQ

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,5}}],"CrossingNumber"->cn,RandomSeed->i],{i,500}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{15,5}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{15,5}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,5}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,5}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,5}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,5}}]]

Halin

GraphData[{"EdgeTransitive",{15,5}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{15,5}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{15,5}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{15,5}},"LCF"]

GraphData[{"EdgeTransitive",{15,5}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,5}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,5}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{15,5}},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

gs={,,,,};

Matchstick

GraphData[{"EdgeTransitive",{15,5}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{15,5}},"Polyhedral"]

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

{"EdgeTransitive", {15, 6}} [planar]

Names

GraphData[{"EdgeTransitive",{15,6}},"StandardName"]

GraphData[{"EdgeTransitive",{15,6}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,6}},"EdgeList"]]

Default embedding

Partition[Range[6],3,2,1]

v=Join[CirclePoints[{1,-Pi/2},6]];
v=Join[v,Sequence@@Most[Subdivide[Mean[v[[{#,#3}]]],v[[#2]],3]]&@@@Partition[Range[6],3,2,1]];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[1,2,3,4,5,6,1,9,3,12,5,15,1,8,3,11,5,14,1,7,3,10,5,13,1]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

GraphPlot@GraphData[{"EdgeTransitive",{15,6}},"Edges"]

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

RecognizeGraph@g

gs=UnlabelGraph/@{,}

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{15,6}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{15,6}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{15,6}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{15,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,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[{"EdgeTransitive",{15,6}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{15,6}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,6}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,6}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,6}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,6}}]]

Halin

GraphData[{"EdgeTransitive",{15,6}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{15,6}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{15,6}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{15,6}},"LCF"]

GraphData[{"EdgeTransitive",{15,6}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,6}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,6}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{15,6}},"UnitDistance"]

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"EdgeTransitive",{15,6}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,6}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{15,6}},"Polyhedral"]

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

{"EdgeTransitive", {15, 7}} == {"CompleteBipartite", {2, 13}}

Names

GraphData[{"EdgeTransitive",{15,7}},"StandardName"]

GraphData[{"EdgeTransitive",{15,7}},"StandardNames"]

{"EdgeTransitive", {15, 8}} == "PetersenLineGraph"

Names

GraphData[{"EdgeTransitive",{15,8}},"StandardName"]

GraphData[{"EdgeTransitive",{15,8}},"StandardNames"]

{"EdgeTransitive", {15, 9}} == {"Circulant", {15, {1, 4}}}

Names

GraphData[{"EdgeTransitive",{15,9}},"StandardName"]

GraphData[{"EdgeTransitive",{15,9}},"StandardNames"]

{"EdgeTransitive", {15, 10}}

Names

GraphData[{"EdgeTransitive",{15,10}},"StandardName"]

GraphData[{"EdgeTransitive",{15,10}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{15,10}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,10}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{15,10}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{15,10}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{15,10}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{15,10}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{15,10}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{15,10}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{15,10}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{15,10}},"Planar"]

GraphData[{"EdgeTransitive",{15,10}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{15,10}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{15,10}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,10}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,10}}],"CrossingNumber"->cn,RandomSeed->i],{i,100}]//Union

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{15,10}},"Circulant"]

GraphData[{"EdgeTransitive",{15,10}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{15,10}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,10}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,10}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,10}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,10}}]]

Halin

GraphData[{"EdgeTransitive",{15,10}},"Halin"]

GraphData[{"EdgeTransitive",{15,10}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{15,10}},"Rigid"]

GraphData[{"EdgeTransitive",{15,10}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{15,10}},"Flexible"]

GraphData[{"EdgeTransitive",{15,10}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{15,10}},"LCF"]

GraphData[{"EdgeTransitive",{15,10}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,10}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,10}},"LCFNotations"]

GraphData[{"EdgeTransitive",{15,10}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{15,10}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{15,10}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{15,10}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{15,10}},"VertexList"],GraphData[{"EdgeTransitive",{15,10}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{15,10}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{15,10}},"Matchstick"]

GraphData[{"EdgeTransitive",{15,10}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,10}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{15,10}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{15,10}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{15,10}},"Polyhedral"]

GraphData[{"EdgeTransitive",{15,10}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {15, 11}}

Names

GraphData[{"EdgeTransitive",{15,11}},"StandardName"]

GraphData[{"EdgeTransitive",{15,11}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{15,11}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,11}},"EdgeList"]]

Default embedding

GraphPlot@RotateGraph[Graph@GraphData[{"EdgeTransitive",{15,11}},"Edges"],-.75]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{15,11}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{15,11}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{15,11}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{15,11}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{15,11}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{15,11}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{15,11}},"Planar"]

GraphData[{"EdgeTransitive",{15,11}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{15,11}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{15,11}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,11}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{15,11}},"Circulant"]

GraphData[{"EdgeTransitive",{15,11}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{15,11}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,11}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,11}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,11}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,11}}]]

Halin

GraphData[{"EdgeTransitive",{15,11}},"Halin"]

GraphData[{"EdgeTransitive",{15,11}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{15,11}},"Rigid"]

GraphData[{"EdgeTransitive",{15,11}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{15,11}},"Flexible"]

GraphData[{"EdgeTransitive",{15,11}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{15,11}},"LCF"]

GraphData[{"EdgeTransitive",{15,11}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,11}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,11}},"LCFNotations"]

GraphData[{"EdgeTransitive",{15,11}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{15,11}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{15,11}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{15,11}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{15,11}},"VertexList"],GraphData[{"EdgeTransitive",{15,11}},"EdgeList"]],MaxIterations->500]

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

GraphPlot@RotateGraph[,{3,6}]

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

RecognizeGraph@g

RectilinearCrossingCount@g

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{15,11}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{15,11}},"Matchstick"]

GraphData[{"EdgeTransitive",{15,11}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,11}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{15,11}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{15,11}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{15,11}},"Polyhedral"]

GraphData[{"EdgeTransitive",{15,11}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {15, 12}}

Names

GraphData[{"EdgeTransitive",{15,12}},"StandardName"]

GraphData[{"EdgeTransitive",{15,12}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{15,12}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,12}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{15,12}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{15,12}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{15,12}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{15,12}},"Graph","Perspective"]//StyleGraphs

Perspective construction

PolyhedronGraph[GraphData[{"EdgeTransitive",{15,12}},"Polyhedron"]]

Bilateral

GraphData[{"EdgeTransitive",{15,12}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{15,12}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{15,12}},"Planar"]

GraphData[{"EdgeTransitive",{15,12}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{15,12}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{15,12}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,12}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,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[{"EdgeTransitive",{15,12}},"Circulant"]

GraphData[{"EdgeTransitive",{15,12}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{15,12}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,12}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,12}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,12}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,12}}]]

Halin

GraphData[{"EdgeTransitive",{15,12}},"Halin"]

GraphData[{"EdgeTransitive",{15,12}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{15,12}},"Rigid"]

GraphData[{"EdgeTransitive",{15,12}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{15,12}},"Flexible"]

GraphData[{"EdgeTransitive",{15,12}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{15,12}},"LCF"]

GraphData[{"EdgeTransitive",{15,12}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,12}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,12}},"LCFNotations"]

GraphData[{"EdgeTransitive",{15,12}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{15,12}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{15,12}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{15,12}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{15,12}},"VertexList"],GraphData[{"EdgeTransitive",{15,12}},"EdgeList"]],MaxIterations->500]

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

GraphPlot@RotateGraph[,{11,15}]

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{15,12}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{15,12}},"Matchstick"]

GraphData[{"EdgeTransitive",{15,12}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,12}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{15,12}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{15,12}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{15,12}},"Polyhedral"]

GraphData[{"EdgeTransitive",{15,12}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {15, 13}} == {"CompleteBipartite", {3, 12}}

Names

GraphData[{"EdgeTransitive",{15,13}},"StandardName"]

GraphData[{"EdgeTransitive",{15,13}},"StandardNames"]

{"EdgeTransitive", {15, 14}}

Names

GraphData[{"EdgeTransitive",{15,14}},"StandardName"]

GraphData[{"EdgeTransitive",{15,14}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{15,14}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{15,14}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{15,14}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{15,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{15,14}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{15,14}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{15,14}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{15,14}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{15,14}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{15,14}},"Planar"]

GraphData[{"EdgeTransitive",{15,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{15,14}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{15,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{15,14}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphData[{"EdgeTransitive",{15,14}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{15,14}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{15,14}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{15,14}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{15,14}}&]

RootGraph[GraphData[{"EdgeTransitive",{15,14}}]]

Halin

GraphData[{"EdgeTransitive",{15,14}},"Halin"]

GraphData[{"EdgeTransitive",{15,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{15,14}},"Rigid"]

GraphData[{"EdgeTransitive",{15,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{15,14}},"Flexible"]

GraphData[{"EdgeTransitive",{15,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{15,14}},"LCF"]

GraphData[{"EdgeTransitive",{15,14}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{15,14}},"LCFSignature"]

GraphData[{"EdgeTransitive",{15,14}},"LCFNotations"]

GraphData[{"EdgeTransitive",{15,14}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{15,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{15,14}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{15,14}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{15,14}},"VertexList"],GraphData[{"EdgeTransitive",{15,14}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{15,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{15,14}},"Matchstick"]

GraphData[{"EdgeTransitive",{15,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{15,14}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{15,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{15,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{15,14}},"Polyhedral"]

GraphData[{"EdgeTransitive",{15,14}},"Graph",{"3D","Polyhedron"}]

16

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 16]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 16],{"EdgeTransitive",_}]],Dividers->All]

{"EdgeTransitive", {16, 4}} [planar]

gs=GraphData[gn={"EdgeTransitive",{16,4}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

pg=PlanarGraph[VertexList[g],EdgeList[g],VertexLabels->"Name"]

Select[SplitBy[Sort[MapIndexed[{#,#2[[1]]}&,v=GraphEmbedding[pg]//Chop]],First],Length[#]>1&]

a=-(Subtract@@v[[{9,8}]])[[1]]/2

g1=System`Graph[VertexList[pg],EdgeList[pg],VertexCoordinates->ReplacePart[v,{4->v[[8]]-{a,0},10->v[[10]]-{0,a},1->v[[1]]+{0,a},5->v[[5]]+{a,0}}],VertexLabels->"Name"]

ToCommonEdges[g1,g]

{"EdgeTransitive", {16, 5}} [planar]

gs=GraphData[gn={"EdgeTransitive",{16,5}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

List@@@EdgeList[g]

Show[pg=PlanarGraph[VertexList[g],EdgeList[g],VertexLabels->"Name"],Axes->True]

v=GraphEmbedding[pg]//Chop[#,1*^-5]&

Select[SplitBy[Sort[MapIndexed[{#,#2[[1]]}&,v]],First],Length[#]>1&]

{v11,v12}=Table[v[[10]]+i.1{#[[2]],-#[[1]]}&@Normalize[Subtract@@v[[{15,13}]]],{i,{-1,1}}]

{v21,v22}=Table[v[[8]]+i.1{#[[2]],-#[[1]]}&@Normalize[Subtract@@v[[{15,14}]]],{i,{-1,1}}]

{v31,v32}=Table[v[[11]]+i.1{#[[2]],-#[[1]]}&@Normalize[Subtract@@v[[{15,16}]]],{i,{-1,1}}]

g1=System`Graph[VertexList[pg],EdgeList[pg],VertexCoordinates->ReplacePart[v,{10->v11,3->v12,8->v21,9->v22,11->v31,12->v32}]]

RecognizeGraph[%]

ToCommonEdges[g1,g]//Chop

{"EdgeTransitive", {16, 7}}

GraphData[{"EdgeTransitive",{16,7}},"StandardName"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{16,7}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{16,7}},"Edges"]

GraphPlot@

v=Join[Flatten[Table[{j,i/2},{j,3},{i,-2,2}],1],{{0,0}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[15,10,5,16,1,6,11,9,12,7,2,16,4,9,5],e[4,8,11],e[1,7,15,9],e[2,8,14,10,3,6,12],e[8,13,10],{6,13},{3,16},{7,14}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount@Annotate[g,VertexLabels->Automatic]

Degenerate

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

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

Bilateral

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

Circular

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

Circular construction

GraphData[{"EdgeTransitive",{16,7}},"|HC|"]

Planar

GraphData[{"EdgeTransitive",{16,7}},"Planar"]

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

Line graph

GraphData[{"EdgeTransitive",{16,7}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{16,7}}]]//Timing

Select[GraphData[All],GraphData[#,"LineGraph","Name"]==={"EdgeTransitive",{16,7}}&]

MinimalCrossing

GraphData[{"EdgeTransitive",{16,7}},{"RCN","CN"}]

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

MinimalCrossing construction cn = 12

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{16,7}}],"CrossingNumber"->12,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"EdgeTransitive",{16,7}},"V"]&]]//Timing

MinimalCrossing construction cn = 10

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{16,7}}],"CrossingNumber"->10,RandomSeed->n]],{n,1000}],Max[OuterFace[#]]<=GraphData[{"EdgeTransitive",{16,7}},"V"]&]]//Timing

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{16,7}}],"CrossingNumber"->10,RandomSeed->i],{i,100}]//Union

MinimalCrossing construction

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

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{16,7}}],"CrossingNumber"->cn,RandomSeed->i],{i,100}]//Union

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{16,7}},"Circulant"]

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

Halin

GraphData[{"EdgeTransitive",{16,7}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{16,7}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{16,7}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{16,7}},"LCF"]

GraphData[{"EdgeTransitive",{16,7}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{16,7}},"LCFSignature"]

GraphData[{"EdgeTransitive",{16,7}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{16,7}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{16,7}},"VertexList"],GraphData[{"EdgeTransitive",{16,7}},"EdgeList"]]]

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

GraphData[{"EdgeTransitive",{16,7}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{16,7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{16,7}},"Polyhedral"]

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

{"EdgeTransitive", {16, 10}}

gs=GraphData[gn={"EdgeTransitive",{16,10}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

17

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 17]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 17],{"EdgeTransitive",_}]],Dividers->All]

18

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 18]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 18],{"EdgeTransitive",_}]],Dividers->All]

{"EdgeTransitive", {18, 3}} [planar]

gs=GraphData[gn={"EdgeTransitive",{18,3}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

Hexagon in hexagon

v=(#-Mean[GraphEmbedding[g]])/Norm[{1.6011070229590048`,0.009417254783307571`}]&/@GraphEmbedding[g]

Show[g1=System`Graph[VertexList[g],EdgeList[g],VertexLabels->"Name",VertexCoordinates->ReplacePart[v,{1->Mean[v[[{13,14}]]],11->Mean[v[[{14,17}]]],7->Mean[v[[{17,15}]]],2->Mean[v[[{15,16}]]],5->Mean[v[[{16,18}]]],9->Mean[v[[{13,18}]]]}]],Axes->True]

v1=CirclePoints[{Sqrt[3]/2,π/6},6];
v2=Mean/@Partition[v1,2,1,1];
v3=CirclePoints[6];

Show[g1=System`Graph[Range[18],Sort[Sort/@Join[
Partition[{2,7,1,12,6,11,5,10,4,9,3,8},2,1,1],
Partition[{16,2,15,1,14,6,13,5,18,4,17,3},2,1,1]
]],VertexLabels->"Name",VertexCoordinates->(vv=Join[v1,v2,v3])],Axes->True]

RecognizeGraph[%]

ToCommonEdges[g1,g]

Dodecagon in hexagon

a=(2/(Sqrt[3]))

Norm[vv[[5]]]/Norm[vv[[11]]]

g2=System`Graph[Range[18],EdgeList[g1],VertexLabels->"Name",VertexCoordinates->(vv2=ReplacePart[vv,(#->a vv[[#]])&/@{11,7,8,9,10,12}])]

ToCommonEdges[g2,g]

Hexagon in dodecagon

g3=System`Graph[Range[18],EdgeList[g1],VertexLabels->"Name",VertexCoordinates->(ReplacePart[vv2,{17->Mean[vv2[[{3,4}]]],16->Mean[vv2[[{2,3}]]],15->Mean[vv2[[{2,1}]]],14->Mean[vv2[[{1,6}]]],13->Mean[vv2[[{6,5}]]],18->Mean[vv2[[{4,5}]]]}])]

ToCommonEdges[g3,g]

All

ToCommonEdges[#,g]&/@{g1,g2,g3}

{"EdgeTransitive", {18, 4}} [planar]

gs=GraphData[gn={"EdgeTransitive",{18,4}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

pg=PlanarGraph[VertexList[g],EdgeList[g],VertexLabels->"Name"]

g1=pg;

v=GraphEmbedding[g1]//Chop

g2=System`Graph[VertexList[pg],EdgeList[pg],VertexLabels->"Name",VertexCoordinates->(v2=ReplacePart[v,{16->Mean[v[[{13,14}]]],17->Mean[v[[{15,13}]]],18->Mean[v[[{15,14}]]],7->v[[14]]+(v[[13]]-v[[14]])/4,9->v[[13]]+(v[[14]]-v[[13]])/4,11->v[[14]]+(v[[15]]-v[[14]])/4,4->v[[15]]+(v[[14]]-v[[15]])/4,2->v[[15]]+(v[[13]]-v[[15]])/4,12->v[[13]]+(v[[15]]-v[[13]])/4}])]

g3=System`Graph[VertexList[g2],EdgeList[g2],VertexLabels->"Name",VertexCoordinates->ReplacePart[v2,{3->Mean[v2[[{16,18}]]],5->Mean[v2[[{16,17}]]],6->Mean[v2[[{17,18}]]]}]]

ToCommonEdges[g3,g]

{"EdgeTransitive", {18, 6}} [planar]

gs=GraphData[gn={"EdgeTransitive",{18,6}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

Show[pg=PlanarGraph[VertexList[g],EdgeList[g],VertexLabels->"Name"],Axes->True]

v=GraphEmbedding[pg]//Chop[#,1*^-5]&

Select[SplitBy[Sort[MapIndexed[{#,#2[[1]]}&,v]],First],Length[#]>1&]//Column

g1=System`Graph[VertexList[pg],EdgeList[pg],VertexLabels->"Name",VertexCoordinates->ReplacePart[v,
{
9->v[[9]]+(v[[2]]-v[[9]])/4,10->v[[9]]+(v[[2]]-v[[9]])/2,11->v[[9]]+(v[[2]]-v[[9]])3/4,
13->v[[12]]+(v[[1]]-v[[12]])/4,14->v[[12]]+(v[[1]]-v[[12]])/2,15->v[[12]]+(v[[1]]-v[[12]])3/4,
5->v[[4]]+(v[[3]]-v[[4]])/4,6->v[[4]]+(v[[3]]-v[[4]])/2,7->v[[4]]+(v[[3]]-v[[4]])3/4
}]]

ToCommonEdges[g1,g]

{"EdgeTransitive", {18, 10}}

gs=GraphData[gn={"EdgeTransitive",{18,10}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

Graph3D[EdgeList[g]]

{"EdgeTransitive", {18, 12}}

gs=GraphData[gn={"EdgeTransitive",{18,12}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

Graph3D[EdgeList[g]]

{"EdgeTransitive", {18, 14}} [LCF]

Names

GraphData[{"EdgeTransitive",{18,14}},"StandardName"]

GraphData[{"EdgeTransitive",{18,14}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{18,14}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{18,14}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{18,14}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{18,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{18,14}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{18,14}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{18,14}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{18,14}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{18,14}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{18,14}},"Planar"]

GraphData[{"EdgeTransitive",{18,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{18,14}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{18,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{18,14}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphData[{"EdgeTransitive",{18,14}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{18,14}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{18,14}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{18,14}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{18,14}}&]

RootGraph[GraphData[{"EdgeTransitive",{18,14}}]]

Halin

GraphData[{"EdgeTransitive",{18,14}},"Halin"]

GraphData[{"EdgeTransitive",{18,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{18,14}},"Rigid"]

GraphData[{"EdgeTransitive",{18,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{18,14}},"Flexible"]

GraphData[{"EdgeTransitive",{18,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{18,14}},"LCF"]

GraphData[{"EdgeTransitive",{18,14}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{18,14}},"LCFSignature"]

GraphData[{"EdgeTransitive",{18,14}},"LCFNotations"]

GraphData[{"EdgeTransitive",{18,14}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"EdgeTransitive",{18,14}}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"EdgeTransitive",{18,14}}],10^5])[[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

Length[FindHamiltonianCycle[GraphData[{"EdgeTransitive",{18,14}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"EdgeTransitive",{18,14}},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

UnitDistance

GraphData[{"EdgeTransitive",{18,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{18,14}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{18,14}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{18,14}},"VertexList"],GraphData[{"EdgeTransitive",{18,14}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{18,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{18,14}},"Matchstick"]

GraphData[{"EdgeTransitive",{18,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{18,14}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{18,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{18,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{18,14}},"Polyhedral"]

GraphData[{"EdgeTransitive",{18,14}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {18, 16}}

gs=GraphData[gn={"EdgeTransitive",{18,16}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

{"EdgeTransitive", {18, 19}} [VT, LCF]

Names

GraphData[{"EdgeTransitive",{18,19}},"StandardName"]

GraphData[{"EdgeTransitive",{18,19}},"StandardNames"]

Primary

GraphData[{"EdgeTransitive",{18,19}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"EdgeTransitive",{18,19}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{18,19}},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"EdgeTransitive",{18,19}},"Edges"]

GraphPlot@g

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{18,19}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{18,19}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{18,19}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{18,19}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{18,19}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{18,19}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{18,19}},"Planar"]

GraphData[{"EdgeTransitive",{18,19}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{18,19}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{18,19}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{18,19}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{18,19}}],TimeConstraint->10])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{18,19}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{18,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[{"EdgeTransitive",{18,19}},"Circulant"]

GraphData[{"EdgeTransitive",{18,19}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{18,19}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{18,19}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{18,19}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{18,19}}&]

RootGraph[GraphData[{"EdgeTransitive",{18,19}}]]

Halin

GraphData[{"EdgeTransitive",{18,19}},"Halin"]

GraphData[{"EdgeTransitive",{18,19}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{18,19}},"Rigid"]

GraphData[{"EdgeTransitive",{18,19}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{18,19}},"Flexible"]

GraphData[{"EdgeTransitive",{18,19}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{18,19}},"LCF"]

GraphData[{"EdgeTransitive",{18,19}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{18,19}},"LCFSignature"]

GraphData[{"EdgeTransitive",{18,19}},"LCFNotations"]

GraphData[{"EdgeTransitive",{18,19}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"EdgeTransitive",{18,19}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"EdgeTransitive",{18,19}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"EdgeTransitive",{18,19}},".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[{"EdgeTransitive",{18,19}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{18,19}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{18,19}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{18,19}},"VertexList"],GraphData[{"EdgeTransitive",{18,19}},"EdgeList"]],MaxIterations->500]

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

g=LabelGraph@RotateGraph[,{17,7}]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{18,19}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{18,19}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{18,19}},"Matchstick"]

GraphData[{"EdgeTransitive",{18,19}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{18,19}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{18,19}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{18,19}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{18,19}},"Polyhedral"]

GraphData[{"EdgeTransitive",{18,19}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {18, 24}} == {"RookComplement", {3, 6}} [VT, LCF]

GraphData[{"EdgeTransitive",{18,24}},"StandardName"]

19

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 19]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 19],{"EdgeTransitive",_}]],Dividers->All]

20

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@GraphData[{"Connected","EdgeTransitive"}, 20]],Dividers->All]

TextGrid[Sort[{GraphData[#,"NotationRules","EdgeTransitive"],#}&/@Cases[GraphData[{"Connected","EdgeTransitive"}, 20],{"EdgeTransitive",_}]],Dividers->All]

{"EdgeTransitive", {20, 1}} == {"Star", 20}

Names

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

GraphData[{"EdgeTransitive",{20,2}},"StandardNames"]

{"EdgeTransitive", {20, 2}} == {"Cycle", 20}

Names

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

GraphData[{"EdgeTransitive",{20,2}},"StandardNames"]

{"EdgeTransitive", {20, 3}} == "SubdividedCubicalGraph"

Names

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

GraphData[{"EdgeTransitive",{20,3}},"StandardNames"]

{"EdgeTransitive", {20, 4}} == "DesarguesGraph"

Names

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

GraphData[{"EdgeTransitive",{20,4}},"StandardNames"]

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

Names

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

GraphData[{"EdgeTransitive",{20,5}},"StandardNames"]

{"EdgeTransitive", {20, 6}} [planar]

Names

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

GraphData[{"EdgeTransitive",{20,6}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,6}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,6}},"Edges"]

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

RecognizeGraph[g]

v1=CirclePoints[5];
v2=Mean/@Partition[v1,2,1,1];
v3=CirclePoints[{1,π/2+π/5},5];
vv=Join[v1,v2,v3];

c=Mean[vv[[#]]]&/@{{9,12},{10,13},{6,14},{7,15},{8,11}};

g=Graph[Range[20],Sort[Sort/@Join[
Partition[{5,10,1,6,2,7,3,8,4,9},2,1,1],
Partition[{12,5,13,1,14,2,15,3,11,4},2,1,1],
Partition[{4,16,5,17,1,18,2,19,3,20},2,1,1]
]],VertexCoordinates->Join[vv,c],VertexLabels->"Name"]

RecognizeGraph[g1]

Transpose[{Range[1,9,2],Range[11,15]}]

v=CirclePoints[{1,-Pi/2},10];
v=Join[v,(Mean[v[[#]]]&/@RotateRight@Partition[Range[2,10,2],2,1,1])];
v=Join[v,v[[#2]]+(v[[#2]]-v[[#]])&@@@Transpose[{Range[1,9,2],Range[11,15]}]];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[1,2,3,4,5,6,7,8,9,10,1],e[10,11,2,12,4,13,6,14,8,15,10,16,2,17,4,18,6,19,8,20,10]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

EdgeLengths@g//FullSimplify//N

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{20,6}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,6}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{20,6}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{20,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,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[{"EdgeTransitive",{20,6}},"Circulant"]

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

Complement graph

GraphData[{"EdgeTransitive",{20,6}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,6}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,6}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,6}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,6}}]]

Halin

GraphData[{"EdgeTransitive",{20,6}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{20,6}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{20,6}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{20,6}},"LCF"]

GraphData[{"EdgeTransitive",{20,6}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,6}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,6}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{20,6}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"EdgeTransitive",{20,6}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,6}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{20,6}},"Polyhedral"]

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

{"EdgeTransitive", {20, 7}}

Names

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

GraphData[{"EdgeTransitive",{20,7}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,7}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,7}},"Edges"]

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

RecognizeGraph[g]

PlanarGraph[VertexList[g],EdgeList[g],VertexLabels->"Name"]

v1=CirclePoints[4];
v2=CirclePoints[{1,π/2},4];
v3=Mean/@Partition[v2,2,1,1];
v=Join[v1,v2,v3];

c=Flatten[Table[v[[#1]]+i/3(v[[#2]]-v[[#1]]),{i,2}]&@@@{{10,4},{11,1},{12,2},{9,3}},1]

Length[%]

g1=System`Graph[Range[20],Sort[Sort/@Join[
Partition[{1,8,2,5,3,6,4,7},2,1,1],
Partition[{7,11,8,12,5,9,6,10},2,1,1],
{{7,15},{15,8},{7,16},{16,8},{5,19},{19,6},{5,20},{20,6},{7,13},{13,6},{7,14},{14,6},{8,17},{17,5},{8,18},{18,5}}
]],VertexCoordinates->Join[v,c],VertexLabels->Placed["Name",Above]]

RecognizeGraph[g1]

Degenerate

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

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

Perspective

GraphData[{"EdgeTransitive",{20,7}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,7}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"EdgeTransitive",{20,7}},"Planar"]

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

MinimalCrossing

GraphData[{"EdgeTransitive",{20,7}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,7}}],"CrossingNumber"->cn])//PolyhedralGraphQ

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

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

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

Complement graph

GraphData[{"EdgeTransitive",{20,7}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,7}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,7}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,7}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,7}}]]

Halin

GraphData[{"EdgeTransitive",{20,7}},"Halin"]

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

Rigid

GraphData[{"EdgeTransitive",{20,7}},"Rigid"]

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

Flexible

GraphData[{"EdgeTransitive",{20,7}},"Flexible"]

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

LCF

GraphData[{"EdgeTransitive",{20,7}},"LCF"]

GraphData[{"EdgeTransitive",{20,7}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,7}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,7}},"LCFNotations"]

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

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

UnitDistance

GraphData[{"EdgeTransitive",{20,7}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"EdgeTransitive",{20,7}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{20,7}},"Polyhedral"]

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

{"EdgeTransitive", {20, 8}} == {"CompleteBipartite", {2, 18}}

Names

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

GraphData[{"EdgeTransitive",{20,8}},"StandardNames"]

{"EdgeTransitive", {20, 9}} == {"Circulant", {20, {1, 9}}}

Names

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

GraphData[{"EdgeTransitive",{20,9}},"StandardNames"]

{"EdgeTransitive", {20, 10}} == {"Haar", 525}

Names

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

GraphData[{"EdgeTransitive",{20,10}},"StandardNames"]

{"EdgeTransitive", {20, 11}} == {"NoncayleyTransitive", {20, 4}}

Names

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

GraphData[{"EdgeTransitive",{20,11}},"StandardNames"]

{"EdgeTransitive", {20, 12}} == "FolkmanGraph"

Names

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

GraphData[{"EdgeTransitive",{20,12}},"StandardNames"]

{"EdgeTransitive", {20, 13}}

Names

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

GraphData[{"EdgeTransitive",{20,13}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{20,13}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,13}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,13}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,13}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,13}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,13}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,13}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,13}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,13}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,13}},"Planar"]

GraphData[{"EdgeTransitive",{20,13}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,13}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,13}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,13}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,13}},"Circulant"]

GraphData[{"EdgeTransitive",{20,13}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,13}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,13}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,13}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,13}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,13}}]]

Halin

GraphData[{"EdgeTransitive",{20,13}},"Halin"]

GraphData[{"EdgeTransitive",{20,13}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,13}},"Rigid"]

GraphData[{"EdgeTransitive",{20,13}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,13}},"Flexible"]

GraphData[{"EdgeTransitive",{20,13}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,13}},"LCF"]

GraphData[{"EdgeTransitive",{20,13}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,13}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,13}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,13}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{20,13}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,13}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,13}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,13}},"VertexList"],GraphData[{"EdgeTransitive",{20,13}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,13}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,13}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,13}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,13}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,13}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,13}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,13}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,13}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {20, 14}}

Names

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

GraphData[{"EdgeTransitive",{20,14}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{20,14}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,14}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,14}},"Edges"]

GraphPlot@RotateGraph[GraphicsToGraph@,{4,11}]

v=Join[CirclePoints[{1,-Pi/2},8],CirclePoints[{1/Sqrt[2],-Pi/2},8]];
v=Join[v,Mean[v[[#]]]&/@Table[{i,i+8},{i,2,8,2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[{1,8},1,17,3,18,5,19,7,20,1,10,3,12,5,14,7,16,1],e[8,9,2,11,4,13,6,15,8],e[{9,16},9,17,11,18,13,19,15,20,9]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,14}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,14}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,14}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,14}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,14}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,14}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,14}},"Planar"]

GraphData[{"EdgeTransitive",{20,14}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,14}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,14}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,14}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphPlot@

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,14}},"Circulant"]

GraphData[{"EdgeTransitive",{20,14}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,14}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,14}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,14}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,14}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,14}}]]

Halin

GraphData[{"EdgeTransitive",{20,14}},"Halin"]

GraphData[{"EdgeTransitive",{20,14}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,14}},"Rigid"]

GraphData[{"EdgeTransitive",{20,14}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,14}},"Flexible"]

GraphData[{"EdgeTransitive",{20,14}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,14}},"LCF"]

GraphData[{"EdgeTransitive",{20,14}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,14}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,14}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,14}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{20,14}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,14}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,14}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,14}},"VertexList"],GraphData[{"EdgeTransitive",{20,14}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

GraphPlot@

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,14}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,14}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,14}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,14}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,14}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,14}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,14}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,14}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {20, 15}}

Names

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

GraphData[{"EdgeTransitive",{20,15}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{20,15}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,15}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,15}},"Edges"]

v=Join[CirclePoints[12],CirclePoints[{1/2,-Pi/2},6]];
v=Join[v,Subdivide[v[[13]],v[[16]],3][[2;;-2]]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[11,1,2,3,14,4,15,3,5,6,15,7,17,6,8,9,18,10,17,9,11,13,2,12,18,1,14,16,18,20,14,12,11,10,8,7,5,16,8,20,5],e[11,19,2,4,5],e[17,19,15],e[17,13,15]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,15}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,15}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,15}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,15}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,15}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,15}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,15}},"Planar"]

GraphData[{"EdgeTransitive",{20,15}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,15}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,15}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,15}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphPlot@RotateGraph[,-Pi/4]

v[[7]]

v=Join[{{-1,0},{0,-1},{1,0},{0,1}},CirclePoints[1/2,6],CirclePoints[{1/8,-Pi/2},4],{{0,(Sqrt[3])/4},-{0,(Sqrt[3])/4}},{{-1/8,(Sqrt[3])/8},{1/8,-(Sqrt[3])/8}},{{-1/4,0},{1/4,0}}];
v[[6]]+={1/8,0};
v[[20]]+={1/8,0};
v[[9]]-={1/8,0};
v[[19]]-={1/8,0};
v[[17]]=Mean[v[[{8,13}]]];
v[[18]]=Mean[v[[{5,11}]]];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,1,10,16,5,3,7,15,8,1],e[2,6],e[6,4,9,2,18,10,9,8,17,7,6,5,20,7,12,11,16,2],e[5,18,11,14,13,12],e[14,8,19,10,14],e[17,13,19,11,20,13],e[13,15,4,17],{5,12}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

v[[16]]={-1,1}v[[18]];
v[[15]]={-1,1}v[[17]];

g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,1,10,16,5,3,7,15,8,1],e[2,6],e[6,4,9,2,18,10,9,8,17,7,6,5,20,7,12,11,16,2],e[5,18,11,14,13,12],e[14,8,19,10,14],e[17,13,19,11,20,13],e[13,15,4,17],{5,12}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

gs=UnlabelGraph/@{,}

Circulant

GraphData[{"EdgeTransitive",{20,15}},"Circulant"]

GraphData[{"EdgeTransitive",{20,15}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,15}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,15}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,15}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,15}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,15}}]]

Halin

GraphData[{"EdgeTransitive",{20,15}},"Halin"]

GraphData[{"EdgeTransitive",{20,15}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,15}},"Rigid"]

GraphData[{"EdgeTransitive",{20,15}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,15}},"Flexible"]

GraphData[{"EdgeTransitive",{20,15}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,15}},"LCF"]

GraphData[{"EdgeTransitive",{20,15}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,15}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,15}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,15}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{20,15}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,15}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,15}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,15}},"VertexList"],GraphData[{"EdgeTransitive",{20,15}},"EdgeList"]],MaxIterations->500]

GraphPlot@RotateGraph[,{19,20}]

v=Join[CirclePoints[{1,-Pi/2},8],CirclePoints[{1/Sqrt[2],-Pi/2},4],CirclePoints[1/2,4],{0,#/2}&/@{-1,1,-1/2,1/2}];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[{1,8},1,13,3,14,5,15,7,16,1],e[2,10,4,11,6,12,8,9,2,17,8],e[6,18,4],e[15,12,16,18,13,10,14,17,15,19,14],e[16,20,13],e[15,11,14],e[8,19,2],e[6,20,4],e[16,9,13]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,15}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,15}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,15}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,15}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,15}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,15}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,15}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,15}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,15}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {20, 16}}

Names

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

GraphData[{"EdgeTransitive",{20,16}},"StandardNames"]

Primary

GraphData[{"EdgeTransitive",{20,16}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"EdgeTransitive",{20,16}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,16}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,16}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,16}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,16}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,16}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,16}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,16}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,16}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,16}},"Planar"]

GraphData[{"EdgeTransitive",{20,16}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,16}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,16}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,16}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,16}}],TimeConstraint->10])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,16}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Union[Select[Table[RotateGraph[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,16}}],"CrossingNumber"->cn,RandomSeed->n]],{n,500}],Max[OuterFace[#]]<=GraphData[{"EdgeTransitive",{20,16}},"V"]&]]//Timing

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,16}}],"CrossingNumber"->cn,RandomSeed->i],{i,250}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,16}},"Circulant"]

GraphData[{"EdgeTransitive",{20,16}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,16}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,16}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,16}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,16}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,16}}]]

Halin

GraphData[{"EdgeTransitive",{20,16}},"Halin"]

GraphData[{"EdgeTransitive",{20,16}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,16}},"Rigid"]

GraphData[{"EdgeTransitive",{20,16}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,16}},"Flexible"]

GraphData[{"EdgeTransitive",{20,16}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,16}},"LCF"]

GraphData[{"EdgeTransitive",{20,16}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,16}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,16}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,16}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{20,16}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,16}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,16}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,16}},"VertexList"],GraphData[{"EdgeTransitive",{20,16}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,16}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,16}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,16}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,16}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,16}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,16}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,16}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,16}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,16}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {20, 17}} [minimal crossing is constructible]

Names

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

GraphData[{"EdgeTransitive",{20,17}},"StandardNames"]

Primary

GraphData[{"EdgeTransitive",{20,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"EdgeTransitive",{20,17}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,17}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,17}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,17}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,17}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,17}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,17}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,17}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,17}},"Planar"]

GraphData[{"EdgeTransitive",{20,17}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,17}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,17}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,17}}],TimeConstraint->10])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,17}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,17}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

RotateGraph[,Pi/6]

RotateGraph[,2Pi/6-Pi/2]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,17}},"Circulant"]

GraphData[{"EdgeTransitive",{20,17}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,17}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,17}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,17}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,17}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,17}}]]

Halin

GraphData[{"EdgeTransitive",{20,17}},"Halin"]

GraphData[{"EdgeTransitive",{20,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,17}},"Rigid"]

GraphData[{"EdgeTransitive",{20,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,17}},"Flexible"]

GraphData[{"EdgeTransitive",{20,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,17}},"LCF"]

GraphData[{"EdgeTransitive",{20,17}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,17}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,17}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,17}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{20,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,17}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,17}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,17}},"VertexList"],GraphData[{"EdgeTransitive",{20,17}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,17}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,17}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,17}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,17}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,17}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,17}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {20, 18}} == {"CompleteBipartite", {3, 17}}

Names

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

GraphData[{"EdgeTransitive",{20,18}},"StandardNames"]

{"EdgeTransitive", {20, 19}} == {"Arrangement", {5, 2}}

Names

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

GraphData[{"EdgeTransitive",{20,19}},"StandardNames"]

{"EdgeTransitive", {20, 20}} == "DitrigonalIcosidodecahedralGraph" [LCF]

Names

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

GraphData[{"EdgeTransitive",{20,20}},"StandardNames"]

{"EdgeTransitive", {20, 21}} [VT, LCF]

Names

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

GraphData[{"EdgeTransitive",{20,21}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{20,21}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,21}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,21}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,21}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,21}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,21}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,21}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,21}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,21}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,21}},"Planar"]

GraphData[{"EdgeTransitive",{20,21}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,21}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,21}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,21}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,21}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,21}},"Circulant"]

GraphData[{"EdgeTransitive",{20,21}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,21}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,21}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,21}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,21}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,21}}]]

Halin

GraphData[{"EdgeTransitive",{20,21}},"Halin"]

GraphData[{"EdgeTransitive",{20,21}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,21}},"Rigid"]

GraphData[{"EdgeTransitive",{20,21}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,21}},"Flexible"]

GraphData[{"EdgeTransitive",{20,21}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,21}},"LCF"]

GraphData[{"EdgeTransitive",{20,21}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,21}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,21}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,21}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"EdgeTransitive",{20,21}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"EdgeTransitive",{20,21}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"EdgeTransitive",{20,21}},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

UnitDistance

GraphData[{"EdgeTransitive",{20,21}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,21}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,21}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,21}},"VertexList"],GraphData[{"EdgeTransitive",{20,21}},"EdgeList"]],MaxIterations->500]

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

g=LabelGraph@RotateGraph[,{7,5}]

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,21}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,21}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,21}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,21}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,21}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,21}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,21}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,21}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {20, 22}} == {"NoncayleyTransitive", {20, 12}}

Names

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

GraphData[{"EdgeTransitive",{20,22}},"StandardNames"]

{"EdgeTransitive", {20, 23}} == {"Circulant", {20, {1, 6, 9}}}

Names

GraphData[{"EdgeTransitive",{20,23}},"StandardName"]

GraphData[{"EdgeTransitive",{20,23}},"StandardNames"]

{"EdgeTransitive", {20, 24}}

Names

GraphData[{"EdgeTransitive",{20,24}},"StandardName"]

GraphData[{"EdgeTransitive",{20,24}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{20,24}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,24}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,24}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,24}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,24}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,24}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,24}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,24}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,24}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,24}},"Planar"]

GraphData[{"EdgeTransitive",{20,24}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,24}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,24}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,24}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,24}},"Circulant"]

GraphData[{"EdgeTransitive",{20,24}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,24}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,24}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,24}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,24}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,24}}]]

Halin

GraphData[{"EdgeTransitive",{20,24}},"Halin"]

GraphData[{"EdgeTransitive",{20,24}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,24}},"Rigid"]

GraphData[{"EdgeTransitive",{20,24}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,24}},"Flexible"]

GraphData[{"EdgeTransitive",{20,24}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,24}},"LCF"]

GraphData[{"EdgeTransitive",{20,24}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,24}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,24}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,24}},"Graph","LCF"]//StyleGraphs

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

UnitDistance

GraphData[{"EdgeTransitive",{20,24}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,24}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,24}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceGraphEmbeddingQ[%]

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,24}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,24}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,24}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,24}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,24}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,24}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,24}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,24}},"Graph",{"3D","Polyhedron"}]

{"EdgeTransitive", {20, 25}} [LCF]

Names

GraphData[{"EdgeTransitive",{20,25}},"StandardName"]

GraphData[{"EdgeTransitive",{20,25}},"StandardNames"]

Primary

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

All

GraphData[{"EdgeTransitive",{20,25}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,25}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"EdgeTransitive",{20,25}},"Edges"]

GraphPlot@RotateGraph[GraphicsToGraph@,-Pi/2]

v=Join[CirclePoints[12],CirclePoints[1/3,7],{{0,0}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[19,2,3,5,4,15,6,16,7,8,9,11,10,12,3,15,19,12,9,17,7,15,18,11,13,1,4,2,13,5,14,2],e[8,10,20,7],e[9,20,4,12,18,8,19,11,14,1,3,20,6,5,7],e[6,17,10],e[14,17,13],e[10,1],{2,18},e[19,16,13],e[18,16,14],{1,9},{6,8}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,25}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,25}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,25}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,25}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,25}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,25}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,25}},"Planar"]

GraphData[{"EdgeTransitive",{20,25}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,25}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,25}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,25}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,25}},"Circulant"]

GraphData[{"EdgeTransitive",{20,25}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,25}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,25}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,25}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,25}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,25}}]]

Halin

GraphData[{"EdgeTransitive",{20,25}},"Halin"]

GraphData[{"EdgeTransitive",{20,25}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,25}},"Rigid"]

GraphData[{"EdgeTransitive",{20,25}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,25}},"Flexible"]

GraphData[{"EdgeTransitive",{20,25}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,25}},"LCF"]

GraphData[{"EdgeTransitive",{20,25}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,25}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,25}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,25}},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"EdgeTransitive",{20,25}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"EdgeTransitive",{20,25}},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

UnitDistance

GraphData[{"EdgeTransitive",{20,25}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,25}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,25}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,25}},"VertexList"],GraphData[{"EdgeTransitive",{20,25}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,25}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,25}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,25}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,25}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"EdgeTransitive",{20,25}},"Polyhedral"]

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

{"EdgeTransitive", {20, 26}} == {"CompleteBipartite", {4, 16}}

Names

GraphData[{"EdgeTransitive",{20,26}},"StandardName"]

GraphData[{"EdgeTransitive",{20,26}},"StandardNames"]

{"EdgeTransitive", {20, 27}}

gs=GraphData[gn={"EdgeTransitive",{20,27}},"Graphs"]

GraphData[gn,"ComplementGraph","Name"]

GraphData[gn,"LineGraph","Name"]

Select[GraphData[All],GraphData[#,"LineGraph","Name"]===gn&]

g=GraphData[gn,"Graph","Labeled"]

Through[{EdgeTransitiveGraphQ,VertexTransitiveGraphQ,PlanarGraphQ,HamiltonianGraphQ,PolyhedralGraphQ}[g]]

{"EdgeTransitive", {20, 28}} == {"CompleteBipartite", {5, 15}}

Names

GraphData[{"EdgeTransitive",{20,28}},"StandardName"]

GraphData[{"EdgeTransitive",{20,28}},"StandardNames"]

{"EdgeTransitive", {20, 29}} == {"Circulant", {20, {1, 4, 6, 9}}}

Names

GraphData[{"EdgeTransitive",{20,29}},"StandardName"]

GraphData[{"EdgeTransitive",{20,29}},"StandardNames"]

{"EdgeTransitive", {20, 30}} == {"Circulant", {20, {1, 3, 7, 9}}}

Names

GraphData[{"EdgeTransitive",{20,30}},"StandardName"]

GraphData[{"EdgeTransitive",{20,30}},"StandardNames"]

{"EdgeTransitive", {20, 31}} == {"CompleteBipartite", {6, 14}}

Names

GraphData[{"EdgeTransitive",{20,31}},"StandardName"]

GraphData[{"EdgeTransitive",{20,31}},"StandardNames"]

{"EdgeTransitive", {20, 32}} == {"Tetrahedral", 6}

Names

GraphData[{"EdgeTransitive",{20,32}},"StandardName"]

GraphData[{"EdgeTransitive",{20,32}},"StandardNames"]

{"EdgeTransitive", {20, 33}} == {"Crown", 10}

Names

GraphData[{"EdgeTransitive",{20,33}},"StandardName"]

GraphData[{"EdgeTransitive",{20,33}},"StandardNames"]

{"EdgeTransitive", {20, 34}} == {"CompleteBipartite", {7, 13}}

Names

GraphData[{"EdgeTransitive",{20,34}},"StandardName"]

GraphData[{"EdgeTransitive",{20,34}},"StandardNames"]

{"EdgeTransitive", {20, 35}} == {"CompleteBipartite", {8, 12}}

Names

GraphData[{"EdgeTransitive",{20,35}},"StandardName"]

GraphData[{"EdgeTransitive",{20,35}},"StandardNames"]

{"EdgeTransitive", {20, 36}} == {"CompleteBipartite", {9, 11}}

Names

GraphData[{"EdgeTransitive",{20,36}},"StandardName"]

GraphData[{"EdgeTransitive",{20,36}},"StandardNames"]

{"EdgeTransitive", {20, 37}} == {"CompleteBipartite", {10, 10}}

Names

GraphData[{"EdgeTransitive",{20,37}},"StandardName"]

GraphData[{"EdgeTransitive",{20,37}},"StandardNames"]

{"EdgeTransitive", {20, 38}} [LCF]

Names

GraphData[{"EdgeTransitive",{20,38}},"StandardName"]

GraphData[{"EdgeTransitive",{20,38}},"StandardNames"]

Primary

GraphData[{"EdgeTransitive",{20,38}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"EdgeTransitive",{20,38}},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"EdgeTransitive",{20,38}},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"EdgeTransitive",{20,38}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"EdgeTransitive",{20,38}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"EdgeTransitive",{20,38}},"Graph","Degenerate"]

Perspective

GraphData[{"EdgeTransitive",{20,38}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"EdgeTransitive",{20,38}},"Polyhedron"]

Bilateral

GraphData[{"EdgeTransitive",{20,38}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"EdgeTransitive",{20,38}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"EdgeTransitive",{20,38}},"Planar"]

GraphData[{"EdgeTransitive",{20,38}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"EdgeTransitive",{20,38}},{"RCN","CN"}]

GraphData[{"EdgeTransitive",{20,38}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,38}}],TimeConstraint->1])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,38}}],TimeConstraint->10])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,38}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"EdgeTransitive",{20,38}}],TimeConstraint->3600])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,38}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"EdgeTransitive",{20,38}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"EdgeTransitive",{20,38}},"Circulant"]

GraphData[{"EdgeTransitive",{20,38}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"EdgeTransitive",{20,38}},"ComplementGraph","Name"]

Line graph

GraphData[{"EdgeTransitive",{20,38}},"Line"]

LineGraphQ[GraphData[{"EdgeTransitive",{20,38}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"EdgeTransitive",{20,38}}&]

RootGraph[GraphData[{"EdgeTransitive",{20,38}}]]

Halin

GraphData[{"EdgeTransitive",{20,38}},"Halin"]

GraphData[{"EdgeTransitive",{20,38}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"EdgeTransitive",{20,38}},"Rigid"]

GraphData[{"EdgeTransitive",{20,38}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"EdgeTransitive",{20,38}},"Flexible"]

GraphData[{"EdgeTransitive",{20,38}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"EdgeTransitive",{20,38}},"LCF"]

GraphData[{"EdgeTransitive",{20,38}},"HamiltonianCycleCount"]

GraphData[{"EdgeTransitive",{20,38}},"LCFSignature"]

GraphData[{"EdgeTransitive",{20,38}},"LCFNotations"]

GraphData[{"EdgeTransitive",{20,38}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"EdgeTransitive",{20,38}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

LCF compute 2*^7

Tally[(lcf=LCF[GraphData[{"EdgeTransitive",{20,38}}],2*^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

LCF compute 5*^7

Tally[(lcf=LCF[GraphData[{"EdgeTransitive",{20,38}}],5*^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"EdgeTransitive",{20,38}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"EdgeTransitive",{20,38}},".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[{"EdgeTransitive",{20,38}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"EdgeTransitive",{20,38}}],Debug->True]//Timing

GraphData[{"EdgeTransitive",{20,38}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"EdgeTransitive",{20,38}},"VertexList"],GraphData[{"EdgeTransitive",{20,38}},"EdgeList"]],MaxIterations->500]

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

g=RotateGraph[,{10,20}]

UnitDistance by FindUnitDistanceEmbedding

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,38}}],MaxIterations->5000,"ReturnWithMessage"->True]//Timing

FindUnitDistanceEmbedding[GraphData[{"EdgeTransitive",{20,38}}],MaxIterations->5000,"ReturnWithMessage"->False]//Quiet//Timing

Matchstick

GraphData[{"EdgeTransitive",{20,38}},"Matchstick"]

GraphData[{"EdgeTransitive",{20,38}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"EdgeTransitive",{20,38}},"Edges"]]

3D All

GraphData[{"EdgeTransitive",{20,38}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"EdgeTransitive",{20,38}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"EdgeTransitive",{20,38}},"Polyhedral"]

GraphData[{"EdgeTransitive",{20,38}},"Graph",{"3D","Polyhedron"}]

Algorithms

IGraphM

$Version

<<IGraphM`

DeleteCases[igraphm=Monitor[{g=#,GraphData[#,"EdgeTransitive"],IGEdgeTransitiveQ[GraphData[#]]//Timing}&/@GraphData[All],g],{_,x_,{_,x_}}]//Timing//AbsoluteTiming

Nauty

MyEdgeTransitiveGraphQ

$Version

DeleteCases[Monitor[{g=#,GraphData[#,"EdgeTransitive"],MyEdgeTransitiveGraphQ[GraphData[#]]}&/@GraphData[All],g],{_,x_,x_}]//Timing//AbsoluteTiming

EdgeTransitiveGraphQ

$Version

DeleteCases[Monitor[edgetransitivegraphq={g=#,GraphData[#,"EdgeTransitive"],EdgeTransitiveGraphQ[GraphData[#]]//Timing}&/@GraphData[All],g],{_,x_,{_,x_}}]//Timing//AbsoluteTiming

data=Reverse[SortBy[{#,#2,#3,#3/#2}&@@@Transpose[{igraphm[[All,1]],igraphm[[All,3,1]],edgetransitivegraphq[[All,3,1]]}],Last]];

Take[data,20]

plotdata=Take[#4->#1&@@@data,200]

ListLogPlot[plotdata,ImageSize->Large]

g=GraphData[{"GoethalsSeidelBlockDesign",{5,11}}];

RepeatedTiming[IGEdgeTransitiveQ[g]]

RepeatedTiming[EdgeTransitiveGraphQ[g]]

GraphData

GraphDataString

Connected 12-node

file=OpenWrite["~/et12.m"]

GraphData[{"EdgeTransitive","Connected"},12]

pos=Flatten[Position[RecognizeGraph/@Flatten[et[12]],{},1]]

i=0;
WriteString[file,GraphDataString[#,
"StandardName"->{"EdgeTransitive",{12,pos[[++i]]}},
"Name"->"12 edge\[Hyphen]transitive graph "<>ToString[pos[[i]]],
"Information"->"Edge-TransitiveGraph",
TimeConstraint->10,
Debug->True
]]&/@{K48Subgraph42,K39Subgraph62,K48Subgraph63};

Close[file]

Connected 14-node

file=OpenWrite["~/et14.m"]

new=Cases[MapIndexed[{#,RecognizeGraph[#],{"EdgeTransitive",{14,#2[[1]]}}}&,Flatten[et[14]]],{g_,{},name_}:>{g,name}]

Function[{g,stdname},WriteString[file,GraphDataString[g,
"StandardName"->stdname,
"Name"->ToString[stdname[[2,1]]]<>" edge\[Hyphen]transitive graph "<>ToString[stdname[[2,2]]],
TimeConstraint->10,
Debug->True
]]]@@@new;

Close[file]

Connected 15-node

file=OpenWrite["~/et15.m"]

new=With[{n=15},Cases[MapIndexed[{#,RecognizeGraph[#],{"EdgeTransitive",{n,#2[[1]]}}}&,Flatten[et[n]]],{g_,{},name_}:>{g,name}]]

Function[{g,stdname},WriteString[file,GraphDataString[g,
"StandardName"->stdname,
"Name"->ToString[stdname[[2,1]]]<>" edge\[Hyphen]transitive graph "<>ToString[stdname[[2,2]]],
"Skip"->{"CliqueCoveringNumber","Skewness"},
TimeConstraint->10,
Debug->True
]]]@@@new;

Close[file]

Connected 16-node

file=OpenWrite["~/et16.m"]

new=With[{n=16},Cases[MapIndexed[{#,RecognizeGraph[#],{"EdgeTransitive",{n,#2[[1]]}}}&,Flatten[et[n]]],{g_,{},name_}:>{g,name}]]

Function[{g,stdname},WriteString[file,GraphDataString[g,
"StandardName"->stdname,
"Name"->ToString[stdname[[2,1]]]<>" edge\[Hyphen]transitive graph "<>ToString[stdname[[2,2]]],
"Skip"->{"CliqueCoveringNumber","Skewness"},
TimeConstraint->10,
Debug->True
]]]@@@new;

Close[file]

Connected 18-node

file=OpenWrite["~/et18.m"]

new=With[{n=18},Cases[MapIndexed[{#,RecognizeGraph[#],{"EdgeTransitive",{n,#2[[1]]}}}&,Flatten[et[n]]],{g_,{},name_}:>{g,name}]]

Function[{g,stdname},WriteString[file,GraphDataString[g,
"StandardName"->stdname,
"Name"->ToString[stdname[[2,1]]]<>" edge\[Hyphen]transitive graph "<>ToString[stdname[[2,2]]],
"Skip"->{"Arboricity","CliqueCoveringNumber","ConnectedDominatingSets","Skewness","TuttePolynomial"},
TimeConstraint->10,
Debug->True
]]]@@@new;

Close[file]

Connected 20-node

file=OpenWrite["~/et20.m"]

new=With[{n=20},Cases[MapIndexed[{#,RecognizeGraph[#],{"EdgeTransitive",{n,#2[[1]]}}}&,Flatten[et[n]]],{g_,{}|{"EdgeTransitive",_},name_}:>{g,name}]]

Function[{g,stdname},WriteString[file,GraphDataString[g,
"StandardName"->stdname,
"Name"->ToString[stdname[[2,1]]]<>" edge\[Hyphen]transitive graph "<>ToString[stdname[[2,2]]],
"Skip"->{"Arboricity","CliqueCoveringNumber","ConnectedDominatingSets","Skewness"},
TimeConstraint->10,
Debug->True
]]]@@@new;

Close[file]

Disconnected

Length/@(etnew=DeleteCases[Map[ToEntity,Get["et.m"],{2}],_Entity,{2}]/.ToEntity[g_]:>g//Quiet)

file=OpenWrite["~/et-new.m"]

Do[a[n]=Length@GraphData["EdgeTransitive",n],{n,10}];

WriteString[file,GraphDataString[#,
"StandardName"->{"EdgeTransitive",{n=VertexCount[#],++a[n]}},
"Name"->ToString[n]<>" edge\[Hyphen]transitive graph "<>ToString[a[n]],
TimeConstraint->10,
Debug->True
]]&/@Flatten[etnew];

Close[file]