Rook Complement Graph

Author

Eric W. Weisstein
March 8, 2024

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

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

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

Figure

GraphicsGrid[Table[Show[GraphData[{"RookComplement",{m,n}}]//StyleGraphs[#,VertexSize->{"Scaled",.05}]&,PlotLabel->Style[Row[{m,"×",n}],Directive[Black,FontFamily->"Times"]]],{n,5},{m,n}],Dividers->All]

Special cases

Need {"RookComplement", {6, 3}} for edge-transitive graph with n = 18, m = 90

Already have {"RookComplement", {4, 4}}

Special cases we already have:

{"RookComplement", {1, n}} -> {"Empty", n}
{"RookComplement", {2, n}} -> {"Crown", n}
{"RookComplement", {n - 1, n}} -> {"Circulant", {n (n-1), (numbers not divisible by n or n-1)}}

With[{cl="RookComplement"},TextGrid[Sort[{cl/.GraphData[#,"NotationRules"],GraphData[#,"Name"]}&/@DeleteCases[GraphData[cl],{cl,_}]],Dividers->All]]

Circulant

ords=Sort[Flatten[Table[{m,n},{n,2,10},{m,2,n}],1]]

data=Monitor[Table[res={i,If[CirculantGraphQ[g=System`GraphComplement[RookGraph@@i]],CirculantIndices[g,All],{}]};If[res[[2]]=!={},Print[res]];res,{i,ords}],i]//Timing

Function[i,Print[{i,res=Select[Range[(n=Times@@i)/2],!Or@@Divisible[#,i]&];If[IsomorphicGraphQ[System`CirculantGraph[n,res],System`GraphComplement[RookGraph@@i]],{n,res},{}]}]]/@ords;

(#1->CirculantIndices[System`GraphComplement[RookGraph@@#1]]&)/@circ

rc=SortBy[Flatten[Table[{RecognizeGraph@System`GraphComplement[RookGraph[m,n]],{m,n}},{n,10},{m,n}],1],Last]

new=Rule@@@DeleteCases[rc,{{},_}]

(add=Cases[rc,{{},i_}:>{i,System`GraphComplement[RookGraph@@i]}])[[All,1]]

Embeddings

<<MathWorld`Graphs`

{"RookComplement", {1, 1}} == "SingletonGraph"

Names

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

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

{"RookComplement", {2, 2}} == {"LadderRung", 2}

Names

GraphData[{"RookComplement",{2,2}},"StandardName"]

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

{"RookComplement", {3, 3}} == {"GeneralizedQuadrangle", {2, 1}}

Names

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

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

{"RookComplement", {3, 6}}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{3,6}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{3,6}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"RookComplement",{3,6}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{3,6}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

GraphData[{"RookComplement",{3,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"RookComplement",{3,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[{"RookComplement",{3,6}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{3,6}},"ComplementGraph","Name"]

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{3,6}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"RookComplement",{3,6}}],10^6])[[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^7

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

LCF compute 5*^7

Tally[(lcf=LCF[GraphData[{"RookComplement",{3,6}}],5*^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

gs=NiceLCFGraphs[lcf,4,None]

LCF compute all

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{3,6}},".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[{"RookComplement",{3,6}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

LabelGraph@

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"RookComplement", {4, 4}}

Names

GraphData[{"RookComplement",{4,4}},"StandardName"]

GraphData[{"RookComplement",{4,4}},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{4,4}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{4,4}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

GraphData[{"RookComplement",{4,4}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{4,4}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{4,4}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{4,4}}],TimeConstraint->3060])//AbsoluteTiming

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Complement graph

GraphData[{"RookComplement",{4,4}},"ComplementGraph","Name"]

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

Line graph

GraphData[{"RookComplement",{4,4}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{4,4}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"RookComplement",{4,4}}]]

Halin

GraphData[{"RookComplement",{4,4}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{4,4}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{4,4}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{4,4}},"LCF"]

GraphData[{"RookComplement",{4,4}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{4,4}},"LCFSignature"]

GraphData[{"RookComplement",{4,4}},"LCFNotations"]

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

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

LCF compute all

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

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

MaxMemoryUsed[]/10.^9 "GB"

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

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

UnitDistance

GraphData[{"RookComplement",{4,4}},"UnitDistance"]

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

LabelGraph@

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{4,4}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{4,4}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{4,4}},"Polyhedral"]

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

{"RookComplement", {4, 6}}

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{4,6}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{4,6}},"Edges"]

v={};
g=Graph[Range[Length[v]],Sort[Sort/@(UndirectedEdge@@@{Sequence@@curvededges={}})],VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Circular construction

GraphData[{"RookComplement",{4,6}},"|HC|"]

Length[hc=FindHamiltonianCycle[GraphData[{"RookComplement",{4,6}}],All][[All,All,1]]]

Length[bilat=DeleteDuplicatesBy[
DeleteMissing[BilaterallyRotatedGraph@CircularEmbeddingFromHamiltonianCycle[GraphData[{"RookComplement",{4,6}}],#]&/@hc],
CircularCanonicalGraphEmbedding]]//Timing

gs=bilat

Length[quad=DeleteDuplicatesBy[Union@Select[bilat,BilateralGraphEmbeddingQ[#,Axis->"X"]&],CircularCanonicalGraphEmbedding[#,4]&]]

quad

Planar

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

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

MinimalCrossing

GraphData[{"RookComplement",{4,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

ComputeRandomLCFNotation[{"RookComplement",{4,6}},2,TimeConstraint->120]

lcf={{{-12,-11,-10,-9,-8,-6,-5,-3,4,5,8,9,11},{-12,-10,-8,-7,-6,-5,-3,2,7,8,9,10,11},{-12,-11,-9,-7,-6,-5,-3,2,3,5,6,8,10},{-11,-9,-8,-5,-4,-2,2,3,5,8,9,10,11},{-12,-10,-8,-6,-4,-2,3,4,5,6,7,8,11},{-12,-11,-9,-8,-6,-5,-3,-2,4,5,6,8,9},{-12,-11,-10,-3,2,3,4,5,6,7,9,10,11},{-12,-10,-9,-8,-5,-3,2,4,5,6,7,8,11},{-11,-8,-7,-6,-5,-4,-2,2,5,6,8,9,10},{-11,-10,-9,-8,-5,-4,-3,-2,3,5,8,10,11},{-12,-11,-9,-8,-6,-5,-4,-2,3,5,6,9,11},{-11,-10,-8,-7,-6,-5,-4,3,4,6,8,10,11}},2};

g=LCFGraph@@lcf

BilateralLCFGraph@%

l={{{"RookComplement",{4,6}},{0,Missing["NotAvailable",{lcf}]}}}

PropertyReplace[l,"LCFNotations","13.3"]

RenameGraphFiles[]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

(gs=Flatten[{DeleteMissing[BilateralLCFGraph@@@Cases[lcf,{_,2}]]}])//Timing

Length[gs]

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

(gs=Flatten[{DeleteMissing[BilateralLCFGraph@@@Cases[lcf,{_,2}]]}])//Timing

Length[gs]

LCF compute 10^7

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

(gs=Flatten[{DeleteMissing[BilateralLCFGraph@@@Cases[lcf,{_,2}]]}])//Timing

Length[gs]

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

RotateGraph[,{9,4}]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"RookComplement", {5, 5}}

Names

GraphData[{"RookComplement",{5,5}},"StandardName"]

GraphData[{"RookComplement",{5,5}},"StandardNames"]

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{5,5}},"Configuration"]

GraphData[{"RookComplement",{5,5}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{5,5}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{5,5}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

GraphData[{"RookComplement",{5,5}},"Polyhedron"]

PolyhedronGraph[GraphData[{"RookComplement",{5,5}},"Polyhedron"]]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{5,5}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{5,5}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{5,5}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{5,5}},"ComplementGraph","Name"]

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

Line graph

GraphData[{"RookComplement",{5,5}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{5,5}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"RookComplement",{5,5}}]]

Halin

GraphData[{"RookComplement",{5,5}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{5,5}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{5,5}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{5,5}},"LCF"]

GraphData[{"RookComplement",{5,5}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{5,5}},"LCFSignature"]

GraphData[{"RookComplement",{5,5}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{5,5}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{5,5}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{5,5}},"V"]]

GraphData[{"RookComplement",{5,5}},"HamiltonianCycleCount"]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{5,5}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{5,5}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{5,5}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{5,5}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{5,5}},"Polyhedral"]

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

{"RookComplement", {6, 6}}

Names

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

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

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{6,6}},"Configuration"]

GraphData[{"RookComplement",{6,6}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{6,6}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{6,6}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

GraphData[{"RookComplement",{6,6}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

GraphData[{"RookComplement",{6,6}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Complement graph

GraphData[{"RookComplement",{6,6}},"ComplementGraph","Name"]

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{6,6}}],TimeConstraint->120]

LCF compute 10^5

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

LCF compute 10^6

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

LCF compute 10^7

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

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{6,6}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

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

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{6,6}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

UnitDistance by refinement

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"RookComplement", {7, 7}}

Names

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

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

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{7,7}},"Configuration"]

GraphData[{"RookComplement",{7,7}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{7,7}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{7,7}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"RookComplement",{7,7}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{7,7}},"Polyhedron"]

PolyhedronGraph[GraphData[{"RookComplement",{7,7}},"Polyhedron"]]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{7,7}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{7,7}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{7,7}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{7,7}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{7,7}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{7,7}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{7,7}}&]

RootGraph[GraphData[{"RookComplement",{7,7}}]]

Halin

GraphData[{"RookComplement",{7,7}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{7,7}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{7,7}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{7,7}},"LCF"]

GraphData[{"RookComplement",{7,7}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{7,7}},"LCFSignature"]

GraphData[{"RookComplement",{7,7}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{7,7}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{7,7}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{7,7}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{7,7}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{7,7}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{7,7}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{7,7}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{7,7}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{7,7}},"Polyhedral"]

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

{"RookComplement", {7, 10}}

Circulant indices

Cases[GraphData[gn={"RookComplement",{7,10}},"StandardNames"],{"Circulant",i_}:>i]

CirculantIndices[GraphData[gn],Debug->True]//Timing//AbsoluteTiming

{"RookComplement", {8, 8}}

Names

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

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

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{8,8}},"Configuration"]

GraphData[{"RookComplement",{8,8}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{8,8}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{8,8}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"RookComplement",{8,8}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{8,8}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{8,8}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Complement graph

GraphData[{"RookComplement",{8,8}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{8,8}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{8,8}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{8,8}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{8,8}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"RookComplement", {8, 9}}

Circulant indices

Cases[GraphData[gn={"RookComplement",{8,9}},"StandardNames"],{"Circulant",i_}:>i]

CirculantIndices[GraphData[gn],Debug->True]//Timing

{"RookComplement", {9, 9}}

Names

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

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

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{9,9}},"Configuration"]

GraphData[{"RookComplement",{9,9}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{9,9}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{9,9}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

GraphData[{"RookComplement",{9,9}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{9,9}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{9,9}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{9,9}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{9,9}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{9,9}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{9,9}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"RookComplement",{9,9}}]]

Halin

GraphData[{"RookComplement",{9,9}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{9,9}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{9,9}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{9,9}},"LCF"]

GraphData[{"RookComplement",{9,9}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{9,9}},"LCFSignature"]

GraphData[{"RookComplement",{9,9}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{9,9}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{9,9}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{9,9}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{9,9}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{9,9}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{9,9}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{9,9}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{9,9}},"Polyhedral"]

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

{"RookComplement", {10, 10}}

Names

GraphData[{"RookComplement",{10,10}},"StandardName"]

GraphData[{"RookComplement",{10,10}},"StandardNames"]

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{10,10}},"Configuration"]

GraphData[{"RookComplement",{10,10}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{10,10}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{10,10}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"RookComplement",{10,10}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{10,10}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{10,10}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{10,10}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{10,10}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{10,10}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{10,10}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{10,10}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{10,10}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{10,10}}&]

RootGraph[GraphData[{"RookComplement",{10,10}}]]

Halin

GraphData[{"RookComplement",{10,10}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{10,10}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{10,10}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{10,10}},"LCF"]

GraphData[{"RookComplement",{10,10}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{10,10}},"LCFSignature"]

GraphData[{"RookComplement",{10,10}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{10,10}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{10,10}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{10,10}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{10,10}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{10,10}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{10,10}},"VertexList"],GraphData[{"RookComplement",{10,10}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{10,10}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{10,10}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{10,10}},"Polyhedral"]

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

{"RookComplement", {11, 11}}

Names

GraphData[{"RookComplement",{11,11}},"StandardName"]

GraphData[{"RookComplement",{11,11}},"StandardNames"]

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{11,11}},"Configuration"]

GraphData[{"RookComplement",{11,11}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{11,11}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{11,11}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"RookComplement",{11,11}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{11,11}},"Polyhedron"]

PolyhedronGraph[GraphData[{"RookComplement",{11,11}},"Polyhedron"]]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{11,11}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{11,11}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{11,11}}],TimeConstraint->86400])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{11,11}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{11,11}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{11,11}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{11,11}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{11,11}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{11,11}}&]

RootGraph[GraphData[{"RookComplement",{11,11}}]]

Halin

GraphData[{"RookComplement",{11,11}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{11,11}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{11,11}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{11,11}},"LCF"]

GraphData[{"RookComplement",{11,11}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{11,11}},"LCFSignature"]

GraphData[{"RookComplement",{11,11}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{11,11}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{11,11}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{11,11}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{11,11}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RookComplement",{11,11}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{11,11}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{11,11}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{11,11}},"VertexList"],GraphData[{"RookComplement",{11,11}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{11,11}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{11,11}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{11,11}},"Polyhedral"]

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

{"RookComplement", {12, 12}}

Names

GraphData[{"RookComplement",{12,12}},"StandardName"]

GraphData[{"RookComplement",{12,12}},"StandardNames"]

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{12,12}},"Configuration"]

GraphData[{"RookComplement",{12,12}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{12,12}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{12,12}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

GraphData[{"RookComplement",{12,12}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{12,12}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{12,12}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{12,12}}],TimeConstraint->86400])//AbsoluteTiming

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{12,12}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{12,12}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{12,12}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{12,12}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"RookComplement",{12,12}}]]

Halin

GraphData[{"RookComplement",{12,12}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{12,12}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{12,12}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{12,12}},"LCF"]

GraphData[{"RookComplement",{12,12}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{12,12}},"LCFSignature"]

GraphData[{"RookComplement",{12,12}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{12,12}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{12,12}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{12,12}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RookComplement",{12,12}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{12,12}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{12,12}},"UnitDistance"]

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

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

UnitDistance by refinement

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{12,12}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{12,12}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{12,12}},"Polyhedral"]

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

{"RookComplement", {13, 13}}

SetSystemOptions["GraphOptions"->{"EdgeCountThreshold"->13000}];

Names

GraphData[{"RookComplement",{13,13}},"StandardName"]

GraphData[{"RookComplement",{13,13}},"StandardNames"]

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{13,13}},"Configuration"]

GraphData[{"RookComplement",{13,13}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{13,13}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{13,13}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

GraphData[{"RookComplement",{13,13}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{13,13}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{13,13}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{13,13}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{13,13}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{13,13}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{13,13}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{13,13}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{13,13}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{13,13}}&]

RootGraph[GraphData[{"RookComplement",{13,13}}]]

Halin

GraphData[{"RookComplement",{13,13}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{13,13}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{13,13}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{13,13}},"LCF"]

GraphData[{"RookComplement",{13,13}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{13,13}},"LCFSignature"]

GraphData[{"RookComplement",{13,13}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{13,13}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{13,13}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{13,13}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{13,13}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{13,13}},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{13,13}},"VertexList"],GraphData[{"RookComplement",{13,13}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{13,13}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{13,13}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{13,13}},"Polyhedral"]

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

{"RookComplement", {14, 14}}

SetSystemOptions["GraphOptions"->{"EdgeCountThreshold"->17000}];

Names

GraphData[{"RookComplement",{14,14}},"StandardName"]

GraphData[{"RookComplement",{14,14}},"StandardNames"]

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{14,14}},"Configuration"]

GraphData[{"RookComplement",{14,14}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{14,14}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{14,14}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

GraphData[{"RookComplement",{14,14}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{14,14}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{14,14}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{14,14}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{14,14}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{14,14}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{14,14}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"RookComplement",{14,14}}]]

Halin

GraphData[{"RookComplement",{14,14}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{14,14}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{14,14}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{14,14}},"LCF"]

GraphData[{"RookComplement",{14,14}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{14,14}},"LCFSignature"]

GraphData[{"RookComplement",{14,14}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{14,14}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{14,14}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{14,14}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{14,14}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{14,14}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{14,14}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{14,14}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{14,14}},"Polyhedral"]

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

{"RookComplement", {15, 15}}

SetSystemOptions["GraphOptions"->{"EdgeCountThreshold"->23000}];

Names

GraphData[{"RookComplement",{15,15}},"StandardName"]

GraphData[{"RookComplement",{15,15}},"StandardNames"]

Primary

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

All

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

Configuration

GraphData[{"RookComplement",{15,15}},"Configuration"]

GraphData[{"RookComplement",{15,15}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{15,15}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{15,15}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

GraphData[{"RookComplement",{15,15}},"Polyhedron"]

Bilateral

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

Circular

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

Planar

GraphData[{"RookComplement",{15,15}},"Planar"]

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

MinimalCrossing

GraphData[{"RookComplement",{15,15}},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{15,15}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RookComplement",{15,15}}],TimeConstraint->3600])//AbsoluteTiming

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{15,15}},"Circulant"]

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

Complement graph

GraphData[{"RookComplement",{15,15}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{15,15}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{15,15}}]]//Timing

RootGraph

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

RootGraph[GraphData[{"RookComplement",{15,15}}]]

Halin

GraphData[{"RookComplement",{15,15}},"Halin"]

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

Rigid

GraphData[{"RookComplement",{15,15}},"Rigid"]

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

Flexible

GraphData[{"RookComplement",{15,15}},"Flexible"]

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

LCF

GraphData[{"RookComplement",{15,15}},"LCF"]

GraphData[{"RookComplement",{15,15}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{15,15}},"LCFSignature"]

GraphData[{"RookComplement",{15,15}},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{15,15}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{15,15}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{15,15}},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{15,15}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{15,15}},"UnitDistance"]

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{15,15}},"Matchstick"]

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

3D default

Graph3D[GraphData[{"RookComplement",{15,15}},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"RookComplement",{15,15}},"Polyhedral"]

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

{"RookComplement", {16, 16}}

SetSystemOptions["GraphOptions"->{"EdgeCountThreshold"->29000}];

Names

GraphData[{"RookComplement",{16,16}},"StandardName"]

GraphData[{"RookComplement",{16,16}},"StandardNames"]

Primary

GraphData[{"RookComplement",{16,16}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"RookComplement",{16,16}},"Graph","All"]//StyleGraphs

Configuration

GraphData[{"RookComplement",{16,16}},"Configuration"]

GraphData[{"RookComplement",{16,16}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{16,16}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{16,16}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"RookComplement",{16,16}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"RookComplement",{16,16}},"Graph","Degenerate"]

Perspective

GraphData[{"RookComplement",{16,16}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{16,16}},"Polyhedron"]

Bilateral

GraphData[{"RookComplement",{16,16}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"RookComplement",{16,16}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"RookComplement",{16,16}},"Planar"]

GraphData[{"RookComplement",{16,16}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"RookComplement",{16,16}},{"RCN","CN"}]

GraphData[{"RookComplement",{16,16}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{16,16}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RookComplement",{16,16}}],TimeConstraint->3600])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{16,16}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"RookComplement",{16,16}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{16,16}},"Circulant"]

GraphData[{"RookComplement",{16,16}},"Graph","Circulant"]//StyleGraphs

Circulant construction

GraphData[{"RookComplement",{16,16}},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"RookComplement",{16,16}}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"RookComplement",{16,16}},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

GraphData[{"RookComplement",{16,16}},"ComplementGraph","Name"]

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

Line graph

GraphData[{"RookComplement",{16,16}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{16,16}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{16,16}}&]

RootGraph[GraphData[{"RookComplement",{16,16}}]]

Halin

GraphData[{"RookComplement",{16,16}},"Halin"]

GraphData[{"RookComplement",{16,16}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"RookComplement",{16,16}},"Rigid"]

GraphData[{"RookComplement",{16,16}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"RookComplement",{16,16}},"Flexible"]

GraphData[{"RookComplement",{16,16}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"RookComplement",{16,16}},"LCF"]

GraphData[{"RookComplement",{16,16}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{16,16}},"LCFSignature"]

GraphData[{"RookComplement",{16,16}},"LCFNotations"]

GraphData[{"RookComplement",{16,16}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{16,16}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{16,16}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{16,16}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RookComplement",{16,16}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{16,16}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{16,16}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"RookComplement",{16,16}}],Debug->True]//Timing

GraphData[{"RookComplement",{16,16}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{16,16}},"VertexList"],GraphData[{"RookComplement",{16,16}},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

{{"RookComplement",{16,16}},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"RookComplement",{16,16}}],TimeConstraint->300,"Results"->All]//Timing}

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

Matchstick

GraphData[{"RookComplement",{16,16}},"Matchstick"]

GraphData[{"RookComplement",{16,16}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"RookComplement",{16,16}},"Edges"]]

3D All

GraphData[{"RookComplement",{16,16}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"RookComplement",{16,16}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"RookComplement",{16,16}},"Polyhedral"]

GraphData[{"RookComplement",{16,16}},"Graph",{"3D","Polyhedron"}]

{"RookComplement", {17, 17}}

SetSystemOptions["GraphOptions"->{"EdgeCountThreshold"->37000}];

Names

GraphData[{"RookComplement",{17,17}},"StandardName"]

GraphData[{"RookComplement",{17,17}},"StandardNames"]

Primary

GraphData[{"RookComplement",{17,17}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"RookComplement",{17,17}},"Graph","All"]//StyleGraphs

Configuration

GraphData[{"RookComplement",{17,17}},"Configuration"]

GraphData[{"RookComplement",{17,17}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{17,17}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{17,17}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"RookComplement",{17,17}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"RookComplement",{17,17}},"Graph","Degenerate"]

Perspective

GraphData[{"RookComplement",{17,17}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{17,17}},"Polyhedron"]

Bilateral

GraphData[{"RookComplement",{17,17}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"RookComplement",{17,17}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"RookComplement",{17,17}},"Planar"]

GraphData[{"RookComplement",{17,17}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"RookComplement",{17,17}},{"RCN","CN"}]

GraphData[{"RookComplement",{17,17}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{17,17}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RookComplement",{17,17}}],TimeConstraint->3600])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{17,17}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"RookComplement",{17,17}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{17,17}},"Circulant"]

GraphData[{"RookComplement",{17,17}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"RookComplement",{17,17}},"ComplementGraph","Name"]

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

Line graph

GraphData[{"RookComplement",{17,17}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{17,17}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{17,17}}&]

RootGraph[GraphData[{"RookComplement",{17,17}}]]

Halin

GraphData[{"RookComplement",{17,17}},"Halin"]

GraphData[{"RookComplement",{17,17}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"RookComplement",{17,17}},"Rigid"]

GraphData[{"RookComplement",{17,17}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"RookComplement",{17,17}},"Flexible"]

GraphData[{"RookComplement",{17,17}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"RookComplement",{17,17}},"LCF"]

GraphData[{"RookComplement",{17,17}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{17,17}},"LCFSignature"]

GraphData[{"RookComplement",{17,17}},"LCFNotations"]

GraphData[{"RookComplement",{17,17}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{17,17}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{17,17}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{17,17}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RookComplement",{17,17}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{17,17}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{17,17}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"RookComplement",{17,17}}],Debug->True]//Timing

GraphData[{"RookComplement",{17,17}},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{17,17}},"VertexList"],GraphData[{"RookComplement",{17,17}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{17,17}},"Matchstick"]

GraphData[{"RookComplement",{17,17}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"RookComplement",{17,17}},"Edges"]]

3D All

GraphData[{"RookComplement",{17,17}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"RookComplement",{17,17}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"RookComplement",{17,17}},"Polyhedral"]

GraphData[{"RookComplement",{17,17}},"Graph",{"3D","Polyhedron"}]

{"RookComplement", {18, 18}}

Names

GraphData[{"RookComplement",{18,18}},"StandardName"]

GraphData[{"RookComplement",{18,18}},"StandardNames"]

Primary

GraphData[{"RookComplement",{18,18}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"RookComplement",{18,18}},"Graph","All"]//StyleGraphs

Configuration

GraphData[{"RookComplement",{18,18}},"Configuration"]

GraphData[{"RookComplement",{18,18}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{18,18}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{18,18}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"RookComplement",{18,18}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"RookComplement",{18,18}},"Graph","Degenerate"]

Perspective

GraphData[{"RookComplement",{18,18}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{18,18}},"Polyhedron"]

Bilateral

GraphData[{"RookComplement",{18,18}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"RookComplement",{18,18}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"RookComplement",{18,18}},"Planar"]

GraphData[{"RookComplement",{18,18}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"RookComplement",{18,18}},{"RCN","CN"}]

GraphData[{"RookComplement",{18,18}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{18,18}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RookComplement",{18,18}}],TimeConstraint->3600])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{18,18}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"RookComplement",{18,18}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{18,18}},"Circulant"]

GraphData[{"RookComplement",{18,18}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"RookComplement",{18,18}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{18,18}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{18,18}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{18,18}}&]

RootGraph[GraphData[{"RookComplement",{18,18}}]]

Halin

GraphData[{"RookComplement",{18,18}},"Halin"]

GraphData[{"RookComplement",{18,18}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"RookComplement",{18,18}},"Rigid"]

GraphData[{"RookComplement",{18,18}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"RookComplement",{18,18}},"Flexible"]

GraphData[{"RookComplement",{18,18}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"RookComplement",{18,18}},"LCF"]

GraphData[{"RookComplement",{18,18}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{18,18}},"LCFSignature"]

GraphData[{"RookComplement",{18,18}},"LCFNotations"]

GraphData[{"RookComplement",{18,18}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{18,18}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{18,18}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{18,18}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RookComplement",{18,18}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{18,18}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{18,18}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"RookComplement",{18,18}}],Debug->True]//Timing

GraphData[{"RookComplement",{18,18}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{18,18}},"VertexList"],GraphData[{"RookComplement",{18,18}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{18,18}},"Matchstick"]

GraphData[{"RookComplement",{18,18}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"RookComplement",{18,18}},"Edges"]]

3D All

GraphData[{"RookComplement",{18,18}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"RookComplement",{18,18}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"RookComplement",{18,18}},"Polyhedral"]

GraphData[{"RookComplement",{18,18}},"Graph",{"3D","Polyhedron"}]

{"RookComplement", {19, 19}}

SetSystemOptions["GraphOptions"->{"EdgeCountThreshold"->59000}];

Names

GraphData[{"RookComplement",{19,19}},"StandardName"]

GraphData[{"RookComplement",{19,19}},"StandardNames"]

Primary

GraphData[{"RookComplement",{19,19}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"RookComplement",{19,19}},"Graph","All"]//StyleGraphs

Configuration

GraphData[{"RookComplement",{19,19}},"Configuration"]

GraphData[{"RookComplement",{19,19}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{19,19}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{19,19}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"RookComplement",{19,19}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"RookComplement",{19,19}},"Graph","Degenerate"]

Perspective

GraphData[{"RookComplement",{19,19}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{19,19}},"Polyhedron"]

Bilateral

GraphData[{"RookComplement",{19,19}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"RookComplement",{19,19}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"RookComplement",{19,19}},"Planar"]

GraphData[{"RookComplement",{19,19}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"RookComplement",{19,19}},{"RCN","CN"}]

GraphData[{"RookComplement",{19,19}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{19,19}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RookComplement",{19,19}}],TimeConstraint->3600])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{19,19}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"RookComplement",{19,19}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{19,19}},"Circulant"]

GraphData[{"RookComplement",{19,19}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"RookComplement",{19,19}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{19,19}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{19,19}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{19,19}}&]

RootGraph[GraphData[{"RookComplement",{19,19}}]]

Halin

GraphData[{"RookComplement",{19,19}},"Halin"]

GraphData[{"RookComplement",{19,19}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"RookComplement",{19,19}},"Rigid"]

GraphData[{"RookComplement",{19,19}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"RookComplement",{19,19}},"Flexible"]

GraphData[{"RookComplement",{19,19}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"RookComplement",{19,19}},"LCF"]

GraphData[{"RookComplement",{19,19}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{19,19}},"LCFSignature"]

GraphData[{"RookComplement",{19,19}},"LCFNotations"]

GraphData[{"RookComplement",{19,19}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{19,19}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{19,19}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{19,19}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RookComplement",{19,19}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{19,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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{19,19}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"RookComplement",{19,19}}],Debug->True]//Timing

GraphData[{"RookComplement",{19,19}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{19,19}},"VertexList"],GraphData[{"RookComplement",{19,19}},"EdgeList"]],MaxIterations->500]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{19,19}},"Matchstick"]

GraphData[{"RookComplement",{19,19}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"RookComplement",{19,19}},"Edges"]]

3D All

GraphData[{"RookComplement",{19,19}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"RookComplement",{19,19}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"RookComplement",{19,19}},"Polyhedral"]

GraphData[{"RookComplement",{19,19}},"Graph",{"3D","Polyhedron"}]

{"RookComplement", {20, 20}}

SetSystemOptions["GraphOptions"->{"EdgeCountThreshold"->73000}];

Names

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

GraphData[{"RookComplement",{20,20}},"StandardNames"]

Primary

GraphData[{"RookComplement",{20,20}}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"RookComplement",{20,20}},"Graph","All"]//StyleGraphs

Configuration

GraphData[{"RookComplement",{20,20}},"Configuration"]

GraphData[{"RookComplement",{20,20}},"Graph","Configuration"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"RookComplement",{20,20}},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"RookComplement",{20,20}},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"RookComplement",{20,20}},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"RookComplement",{20,20}},"Graph","Degenerate"]

Perspective

GraphData[{"RookComplement",{20,20}},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"RookComplement",{20,20}},"Polyhedron"]

Bilateral

GraphData[{"RookComplement",{20,20}},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"RookComplement",{20,20}},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"RookComplement",{20,20}},"Planar"]

GraphData[{"RookComplement",{20,20}},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"RookComplement",{20,20}},{"RCN","CN"}]

GraphData[{"RookComplement",{20,20}},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(cn=CrossingNumber[GraphData[{"RookComplement",{20,20}}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"RookComplement",{20,20}}],TimeConstraint->3600])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"RookComplement",{20,20}}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"RookComplement",{20,20}}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union//Timing

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"RookComplement",{20,20}},"Circulant"]

GraphData[{"RookComplement",{20,20}},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"RookComplement",{20,20}},"ComplementGraph","Name"]

GraphData[%,"Graph","All"]

GraphComplement/@%

gs=Take[%,2]

Line graph

GraphData[{"RookComplement",{20,20}},"Line"]

LineGraphQ[GraphData[{"RookComplement",{20,20}}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"RookComplement",{20,20}}&]

RootGraph[GraphData[{"RookComplement",{20,20}}]]

Halin

GraphData[{"RookComplement",{20,20}},"Halin"]

GraphData[{"RookComplement",{20,20}},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"RookComplement",{20,20}},"Rigid"]

GraphData[{"RookComplement",{20,20}},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"RookComplement",{20,20}},"Flexible"]

GraphData[{"RookComplement",{20,20}},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"RookComplement",{20,20}},"LCF"]

GraphData[{"RookComplement",{20,20}},"HamiltonianCycleCount"]

GraphData[{"RookComplement",{20,20}},"LCFSignature"]

GraphData[{"RookComplement",{20,20}},"LCFNotations"]

GraphData[{"RookComplement",{20,20}},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"RookComplement",{20,20}}],TimeConstraint->120]

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

l={
{{"RookComplement",{20,20}},{0,Missing["NotAvailable",DeleteCases[nicelcf,{_,XXX}]]}}
}

PropertyReplace[l,"LCFNotations","14.1"]

RenameGraphFiles[]

LCF compute all

Divisors[GraphData[{"RookComplement",{20,20}},"V"]]

Length[FindHamiltonianCycle[GraphData[{"RookComplement",{20,20}}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"RookComplement",{20,20}},".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

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"RookComplement",{20,20}},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"RookComplement",{20,20}}],Debug->True]//Timing

GraphData[{"RookComplement",{20,20}},"Graph","UnitDistance"]//StyleGraphs

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"RookComplement",{20,20}},"VertexList"],GraphData[{"RookComplement",{20,20}},"EdgeList"]],MaxIterations->500]

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"RookComplement",{20,20}},"Matchstick"]

GraphData[{"RookComplement",{20,20}},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"RookComplement",{20,20}},"Edges"]]

3D All

GraphData[{"RookComplement",{20,20}},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"RookComplement",{20,20}},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"RookComplement",{20,20}},"Polyhedral"]

GraphData[{"RookComplement",{20,20}},"Graph",{"3D","Polyhedron"}]

Properties m×n

EdgeCount

DeleteCases[Flatten[Table[{{m,n},GraphData[{"RookComplement",{m,n}},"M"],2Binomial[m,2]Binomial[n,2]},{n,10},{m,n}],1],{_,x_,x_}]

VertexCount

DeleteCases[Flatten[Table[{{m,n},GraphData[{"RookComplement",{m,n}},"V"],m n},{n,10},{m,n}],1],{_,x_,x_}]

Properties n×n

Acyclic

seq=Table[GraphData[{"RookComplement",{n,n}},"Acyclic"],{n,20}]

AdjacencyMatrixCount

seq=Table[GraphData[{"RookComplement",{n,n}},"AdjacencyMatrixCount"],{n,20}]

Table[((((n^2))!)/(Piecewise[{{1,n==1}},2(((n!))^2)])),{n,20}]

Arboricity

Probably 2n-1 for n > 1

seq=Table[GraphData[{"RookComplement",{n,n}},"Arboricity"],{n,20}]

ArcTransitive

seq=Table[GraphData[{"RookComplement",{n,n}},"ArcTransitive"],{n,20}]

ArcTransitivity

seq=Table[GraphData[{"RookComplement",{n,n}},"ArcTransitivity"],{n,20}]

AutomorphismCount

seq=Table[GraphData[{"RookComplement",{n,n}},"AutomorphismCount"],{n,20}]

FindSequenceFunction[Rest@seq,n-1]//FunctionExpand//FullSimplify

Table[Piecewise[{{1,n==1}},2(((n!))^2)],{n,20}]

BalabanIndex

seq=Table[GraphData[{"RookComplement",{n,n}},"BalabanIndex"],{n,20}]

(seq=Table[BalabanIndex[System`GraphComplement[RookGraph[n,n]]],{n,15}])//Timing

Through[{Numerator,Denominator}[seq]]

FindSequenceFunction[Drop[seq,2],n-2]

Bandwidth

seq=Table[GraphData[{"RookComplement",{n,n}},"Bandwidth"],{n,20}]

BridgeCount

seq=Table[GraphData[{"RookComplement",{n,n}},"BridgeCount"],{n,20}]

BurningNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"BurningNumber"],{n,20}]

CharacteristicPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"CharacteristicPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

Table[(x-(((n-1))^2))(((x-1))^(((n-1))^2))(((x+n-1))^(2(n-1))),{n,k0,kmax}]//Column

Chordal

seq=Table[GraphData[{"RookComplement",{n,n}},"Chordal"],{n,20}]

ChordCount

seq=Table[GraphData[{"RookComplement",{n,n}},"ChordCount"],{n,20}]

Chordless

seq=Table[GraphData[{"RookComplement",{n,n}},"Chordless"],{n,20}]

ChordlessCycleCount

seq=Table[GraphData[{"RookComplement",{n,n}},"ChordlessCycleCount"],{n,20}]

FindSequenceFunction[seq,n]

Chords

seq=Table[GraphData[{"RookComplement",{n,n}},"Chords"],{n,20}]

ChromaticallyUnique

seq=Table[GraphData[{"RookComplement",{n,n}},"ChromaticallyUnique"],{n,20}]

GraphData[{"ChromaticallyUnique","RookComplement"}]

ChromaticInvariant

seq=Table[GraphData[{"RookComplement",{n,n}},"ChromaticInvariant"],{n,20}]

FindSequenceFunction[Drop[seq,2],n]

ChromaticNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"ChromaticNumber"],{n,20}]

ChromaticPolynomial

(poly=DeleteMissing@Factor[Table[GraphData[{"RookComplement",{n,n}},"ChromaticPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

Circumference

seq=Table[GraphData[{"RookComplement",{n,n}},"Circumference"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

Classes

Intersection@@(GraphData[#,"Classes"]&/@GraphData["RookComplement"])

CliqueCount

=== IndependentVertexSetCount of Rook n×n

A002720

seq=Table[GraphData[{"RookComplement",{n,n}},"CliqueCount"],{n,20}]

Table[n! LaguerreL[n,-1],{n,20}]

CliqueCoveringNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"CliqueCoveringNumber"],{n,20}]

FindSequenceFunction[Rest@seq,n-10]//FullSimplify

gf=x FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

CliqueNumber

=== IndependenceNumber of Rook n×n

seq=Table[GraphData[{"RookComplement",{n,n}},"CliqueNumber"],{n,20}]

CliquePolynomial

A144084

(poly=DeleteMissing@Factor[Table[GraphData[{"RookComplement",{n,n}},"CliquePolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

CoefficientList[poly,x]//Column

Table[(((-x))^n) HypergeometricU[-n,1,-(1/x)],{n,5}]//Factor//Column

CoefficientList[Table[(((-x))^n) HypergeometricU[-n,1,-(1/x)],{n,5}],x]

CochromaticGraphNames

Table[GraphData[{"RookComplement",{n,n}},"CochromaticGraphNames"],{n,20}]//Column

Select[GraphData["RookComplement"],GraphData[#,"ChromaticallyUnique"]=!=False&]

{{"Book",10},{"Book",11},{"Book",12},{"Book",110},{"Book",14},{"Book",10},{"Book",16},{"Book",17},{"Book",18},{"Book",19},{"Book",20},"DominoGraph","SquareGraph"}

ComplementOddChordlessCycleCount

Probably 0

seq=Table[GraphData[{"RookComplement",{n,n}},"ComplementOddChordlessCycleCount"],{n,20}]

FindSequenceFunction[Take[seq,{10,5}],n]

ConnectedComponentCount

seq=Table[GraphData[{"RookComplement",{n,n}},"ConnectedComponentCount"],{n,20}]

ConnectedDominatingSetCount

A290949

seq=Table[GraphData[{"RookComplement",{n,n}},"ConnectedDominatingSetCount"],{n,20}]

FindSequenceFunction[seq,n]

ConnectedDominationNumber

Possibly 3 for n > 2

seq=Table[GraphData[{"RookComplement",{n,n}},"ConnectedDominationNumber"],{n,20}]

FindSequenceFunction[seq,n]

ConnectedDominationPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"ConnectedDominationPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

ConnectedInducedSubgraphCount

A291593

seq=Table[GraphData[{"RookComplement",{n,n}},"ConnectedInducedSubgraphCount"],{n,20}]

Take[seq=Table[2^(n^2)-2n*(2^n-n-1)-n^2(2^(n-1)-1)^2-Binomial[n,2]^2-1,{n,100}],10]

FullSimplify[2^(n^2)-2n(2^n-n-1)-n^2(2^(n-1)-1)^2-Binomial[n,2]^2-1]

Table[2^(n^2)-2n(2^n-n-1)-n^2(2^(n-1)-1)^2-Binomial[n,2]^2-1,{n,20}]

FindLinearRecurrence[seq]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

ConnectedInducedSubgraphPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"ConnectedInducedSubgraphPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

poly2=Table[XXX,{n,20}]

FullSimplify[poly2-poly]

CrossingNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"CrossingNumber"],{n,20}]

CycleCount

A292197

seq=Table[GraphData[{"RookComplement",{n,n}},"CycleCount"],{n,20}]

FindSequenceFunction[DeleteMissing@seq,n]

CyclePolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"CyclePolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

Cyclic

Table[GraphData[{"RookComplement",{n,n}},"Cyclic"],{n,20}]

CyclomaticNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"CyclomaticNumber"],{n,20}]

Table[2((Binomial[n,2])^2)-(n^2)+If[n==2,2,1],{n,20}]

FindSequenceFunction[seq,n]

DetourIndex

A288959

seq=Table[GraphData[{"RookComplement",{n,n}},"DetourIndex"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]

Table[n^2(n^2-1)^2/2,{n,20}]

DetourMatrix

MatrixForm/@Table[GraphData[{"RookComplement",{n,n}},"DetourMatrix"],{n,5}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,20}]

DetourPolynomial

== DetourPolynomial of Rook n×n except for n == 2

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"DetourPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

Table[Piecewise[{{(-8+x) (((2+x))^2) (4+x),n==2}},(x-((((n^2)-1))^2))(((x+(n^2)-1))^((n^2)-1))],{n,20}]//Column

Diameter

seq=Table[GraphData[{"RookComplement",{n,n}},"Diameter"],{n,20}]

DistanceMatrix

MatrixForm/@Table[GraphData[{"RookComplement",{n,n}},"DistanceMatrix"],{n,5}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,20}]

DistancePolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"DistancePolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

FindSequenceFunction[{12,21,32,45,60,77,96,117},n-2]//Factor

Table[(x-(n-1)(n+3))(((x-n+3))^(2(n-1)))(((x+3))^(((n-1))^2)),{n,20}]//Column

DistinguishingNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"DistinguishingNumber"],{n,20}]

DomaticNumber

Possibly A000212 for n >= 3

seq=Table[GraphData[{"RookComplement",{n,n}},"DomaticNumber"],{n,20}]

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

DominatingSetCount

A292073

seq=Table[GraphData[{"RookComplement",{n,n}},"DominatingSetCount"],{n,20}]

FullSimplify[2^(n^2)-2n(2^n-2)+n^2-n^2(2^(n-1)-1)^2+n^2(n-1)^2-2Binomial[n,2]^2-1]

seq=Table[If[n==1,1,(2^(n^2))+(1/4) n (4 (2^n) (n-2)-(4^n) n+2 ((((n-1))^2) n+8))-1],{n,20}]

seq=Table[If[n==1,1,(2^(n^2))+((2^n) (n-2)-(4^(n-1)) n+(((n-1))^2) n/2+4)n-1],{n,20}]

seq=Table[If[n==1,1,(2^(n^2))+((2^n) (n-2)-(4^(n-1)) n+4)n+2((Binomial[n,2])^2)-1],{n,20}]

FindLinearRecurrence[Rest@seq]

gf=x FindGeneratingFunction[Take[seq,20],x]

DominationNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"DominationNumber"],{n,20}]

DominationPolynomial

(poly=DeleteMissing@Factor[Table[GraphData[{"RookComplement",{n,n}},"DominationPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

CoefficientList[poly,x]//Column

EdgeChromaticNumber

Probably (((n-1))^2) for odd n > 3

seq=Table[GraphData[{"RookComplement",{n,n}},"EdgeChromaticNumber"],{n,20}]

EdgeConnectivity

seq=Table[GraphData[{"RookComplement",{n,n}},"EdgeConnectivity"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

EdgeCount

seq=Table[GraphData[{"RookComplement",{n,n}},"EdgeCount"],{n,20}]

FindSequenceFunction[seq,n]//Factor

2((Binomial[n,2])^2)

EdgeCoverCount

seq=Table[GraphData[{"RookComplement",{n,n}},"EdgeCoverCount"],{n,20}]

EdgeCoverNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"EdgeCoverNumber"],{n,20}]

FindSequenceFunction[seq,n]

x FindGeneratingFunction[seq,x]

EdgeCoverPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"EdgeCoverPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

EulerianCycleCount

seq=Table[GraphData[{"RookComplement",{n,n}},"EulerianCycleCount"],{n,20}]

FaceCount

seq=Table[GraphData[{"RookComplement",{n,n}},"FaceCount"],{n,20}]

FlowPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"FlowPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

FractionalChromaticNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"FractionalChromaticNumber"],{n,20}]

FractionalEdgeChromaticNumber

Probably (((n-1))^2) for even n > 3

seq=Table[GraphData[{"RookComplement",{n,n}},"FractionalEdgeChromaticNumber"],{n,20}]

Girth

seq=Table[GraphData[{"RookComplement",{n,n}},"Girth"],{n,20}]

Gonality

seq=Table[GraphData[{"RookComplement",{n,n}},"Gonality"],{n,20}]

HamiltonConnected

seq=Table[GraphData[{"RookComplement",{n,n}},"HamiltonConnected"],{n,20}]

HamiltonDecompositionCount

seq=Table[GraphData[{"RookComplement",{n,n}},"HamiltonDecompositionCount"],{n,20}]

Hamiltonian

Table[GraphData[{"RookComplement",{n,n}},"Hamiltonian"],{n,20}]

HamiltonianCycleCount

A291865

seq=Table[GraphData[{"RookComplement",{n,n}},"HamiltonianCycleCount"],{n,20}]

2seq

HamiltonianPathCount

A291864

seq=Table[GraphData[{"RookComplement",{n,n}},"HamiltonianPathCount"],{n,20}]

2seq

HamiltonianWalkCount

seq=Table[GraphData[{"RookComplement",{n,n}},"HamiltonianWalkCount"],{n,20}]

HararyIndex

A092364

seq=Table[GraphData[{"RookComplement",{n,n}},"HararyIndex"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

seq=Table[(n-1)(n^3)/2,{n,20}]

seq=Table[(n^2)Binomial[n,2],{n,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{5,-10,10,-5,1},{0,4,27,96,250},20]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((x(4+7 x+(x^2)))/(((-1+x))^5)),{x,0,20}],x]

HexagonCount

A291912

seq=Table[GraphData[{"RookComplement",{n,n}},"HexagonCount"],{n,20}]

(seq=Table[CycleCount[System`GraphComplement[RookGraph[n,n]],6],{n,15}])//Timing

FindSequenceFunction[seq,n]//Factor

seq=Table[(-2+n) (((-1+n))^2) (n^2) (-52+12 n+76 (n^2)-63 (n^3)-2 (n^4)+20 (n^5)-8 (n^6)+(n^7))/12,{n,30}]

coef=FindLinearRecurrence[seq]

"a(n) = "<>StringReplace[StringJoin@@Table[If[coef[[k]]==0,"",Switch[
coef[[k]],
-1," - ",
1," + ",
_,ToString[coef[[k]]]<>"*"]<>"a(n-"<>ToString[k]<>") + "],{k,Length[coef]}]," + -"->" - " ]

Take[seq,Length@coef]

LinearRecurrence[{13,-78,286,-715,1287,-1716,1716,-1287,715,-286,78,-13,1},{0,0,60,18336,840800,14629200,143939460,971877760,5018582016,21193207200,76518984300,243664127520,699965254560},30]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((4 (x^2) (-15-4389 x-151778 (x^2)-1277962 (x^3)-3535266 (x^4)-3576650 (x^5)-1293586 (x^6)-137682 (x^7)-1883 (x^8)+11 (x^9)))/(((-1+x))^13)),{x,0,20}],x]

IdiosyncraticPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"IdiosyncraticPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x,y]])//Column

Table[(x-2(n-1)y-(((n-1))^2))((((n-1)+x-(n-2)y))^(2(n-1)))(((2y+x-1))^(((n-1))^2)),{n,20}]//Column

IndependenceNumber

=== CliqueNumber of Rook n×n

seq=Table[GraphData[{"RookComplement",{n,n}},"IndependenceNumber"],{n,20}]

Do[Print[{n,Length@FindIndependentVertexSet[System`GraphComplement[RookGraph[n,n]]][[1]]//Timing}],{n,20}]

IndependencePolynomial

=== CliquePolynomial of Rook n×n

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"IndependencePolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

IndependenceRatio

seq=Table[GraphData[{"RookComplement",{n,n}},"IndependenceRatio"],{n,20}]

Table[(n/(n^2)),{n,20}]

IndependentEdgeSetCount

A292195

seq=Table[GraphData[{"RookComplement",{n,n}},"IndependentEdgeSetCount"],{n,20}]

IndependentVertexSetCount

A288958

seq=Table[GraphData[{"RookComplement",{n,n}},"IndependentVertexSetCount"],{n,20}]

FindSequenceFunction[Rest@seq,n-1]

Table[1+2*n*(2^n-1)-n^2,{n,20}]

IntersectionNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"IntersectionNumber"],{n,20}]

IrredundancePolynomial

(poly=DeleteMissing@Factor[Table[GraphData[{"RookComplement",{n,n}},"IrredundancePolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

CoefficientList[poly,x]

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

IrredundantSetCount

A291622

Table[GraphData[{"RookComplement",{n,n}},"IrredundantSetCount"],{n,20}]

seq=Table[Piecewise[{{9,n==2},{94,n==3}},2n(2^n)+(5n^6-21n^5+47n^4-51n^3+8n^2-24n+12)/12],{n,30}]

coef=FindLinearRecurrence[Drop[seq,3]]

Take[Drop[seq,3],Length@coef]

Join[{2,9,94},LinearRecurrence[{11,-53,147,-259,301,-231,113,-32,4},{777,3286,10771,29366,69873,149950,297111,553114,980953},20]]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((2-13 x+101 (x^2)-74 (x^3)-1084 (x^4)+3717 (x^5)-7077 (x^6)+9470 (x^7)-7634 (x^8)+3876 (x^9)-1128 (x^10)+144 (x^11))/((((1-x))^7) (((1-2 x))^2))),{x,0,20}],x]

KirchhoffIndex

seq=Table[GraphData[{"RookComplement",{n,n}},"KirchhoffIndex"],{n,20}]

Through[{Numerator,Denominator}[Drop[seq,2]]]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

KirchhoffSumIndex

seq=Table[GraphData[{"RookComplement",{n,n}},"KirchhoffSumIndex"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

LaplacianMatrix

MatrixForm/@Table[GraphData[{"RookComplement",{n,n}},"LaplacianMatrix"],{n,5}]

LaplacianPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"LaplacianPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

FindSequenceFunction[{2,6,12,20,30,42,56,72,90},n-1]//Factor

FindSequenceFunction[{3,8,15,24,35,48,63,80},n-2]//Factor

Table[(((x-(n-1)n))^(2(n-1)))x(((x-(n-2)n))^(((n-1))^2)),{n,20}]//Column

LeafCount

seq=Table[GraphData[{"RookComplement",{n,n}},"LeafCount"],{n,20}]

LongestCycleCount

=== HamiltonianCycleCount

A291865

seq=Table[GraphData[{"RookComplement",{n,n}},"LongestCycleCount"],{n,20}]

LovaszNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"LovaszNumber"],{n,20}]

MatchingGeneratingPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"MatchingGeneratingPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

MatchingNumber

=== Matching number of n ×n Rook

A007590

seq=Table[GraphData[{"RookComplement",{n,n}},"MatchingNumber"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

Table[Floor[n^2/2],{n,20}]

MatchingPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"MatchingPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

MaximalCliqueCount

=== MaximalIndependentVertexSetCount of Rook n×n

A000142

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximalCliqueCount"],{n,20}]

FindSequenceFunction[seq,n]

SeriesCoefficient[FindGeneratingFunction[seq,x],{x,0,n}]

MaximalIndependentEdgeSetCount

A292196

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximalIndependentEdgeSetCount"],{n,20}]

MaximalIndependentVertexSetCount

=== MaximalCliques in Rook n×n

A103517

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximalIndependentVertexSetCount"],{n,20}]

FindSequenceFunction[Rest@seq,n-1]

seq=Join[{1},2Range[2,20]]

FindLinearRecurrence[Rest@seq]

Join[{1},LinearRecurrence[{2,-1},{4,6},20]]

x FindGeneratingFunction[seq,x]

CoefficientList[Series[((1+2 x-(x^2))/(((-1+x))^2)),{x,0,20}],x]

MaximalIrredundantSetCount

=== MinimalDominatingSetCount

A291623

Table[GraphData[{"RookComplement",{n,n}},"MaximalIrredundantSetCount"],{n,20}]

seq=Table[Piecewise[{{1,n==1},{4,n==2}},2n+6Binomial[n,3]^2+n^2(n-1)^2+12Binomial[n,4]Binomial[n,2]],{n,20}]

coef=FindLinearRecurrence[Drop[seq,2]]

Take[Drop[seq,2],Length@coef]

Join[{1,4},LinearRecurrence[{7,-21,35,-35,21,-7,1},{48,320,1610,6012,17948,45488,101970},20]]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((-1+3 x-41 (x^2)-33 (x^3)-273 (x^4)+99 (x^5)-77 (x^6)+27 (x^7)-4 (x^8))/(((-1+x))^7)),{x,0,20}],x]

MaximalIrredundantSetSignature

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximalIrredundantSetSignature"],{n,20}]

MaximumCliqueCount

=== MaximumIndependentVertexSetCount for Rook n×n

A000142

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximumCliqueCount"],{n,20}]

Range[10]!

MaximumIndependentEdgeSetCount

A292198

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximumIndependentEdgeSetCount"],{n,20}]

MaximumIndependentVertexSetCount

=== MaximumCliqueCount for Rook n×n

A103517

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximumIndependentVertexSetCount"],{n,20}]

FindSequenceFunction[Rest@seq,n-1]

MaximumIrredundantSetCount

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximumIrredundantSetCount"],{n,20}]

MaximumLeafNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximumLeafNumber"],{n,20}]

MaximumVertexDegree

seq=Table[GraphData[{"RookComplement",{n,n}},"MaximumVertexDegree"],{n,20}]

FindSequenceFunction[seq,n]

MeanDistance

seq=Table[GraphData[{"RookComplement",{n,n}},"MeanDistance"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

MinimalDominatingSetCount

=== MaximalIrredundantSetCount

A291623

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimalDominatingSetCount"],{n,20}]

Table[Piecewise[{{1,n==1},{4,n==2}},2 n+6 Binomial[n,3]^2+n^2 (n-1)^2+12 Binomial[n,4] Binomial[n,2]],{n,20}]

MinimalDominatingSetSignature

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimalDominatingSetSignature"],{n,20}]

MinimalEdgeCoverCount

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimalEdgeCoverCount"],{n,20}]

MinimalEdgeCoverSignature

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimalEdgeCoverSignature"],{n,20}]

MinimumCliqueCoveringCount

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimumCliqueCoveringCount"],{n,20}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimumConnectedDominatingSetCount"],{n,20}]

FindSequenceFunction[seq,n]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimumDistinguishingLabelingCount"],{n,20}]

MinimumDominatingSetCount

A292074

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimumDominatingSetCount"],{n,20}]

seq=Table[Piecewise[{{1,n==1},{48,n==3}},6Binomial[n,3]^2+n^2(n-1)^2],{n,20}]

coef=FindLinearRecurrence[Drop[seq,3]]

Length@coef

Take[Drop[seq,3],Length@coef]

Join[{1,4,48},LinearRecurrence[{7,-21,35,-35,21,-7,1},{240,1000,3300,9114,21952,47520,94500},20]]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((-1+3 x-41 (x^2)+47 (x^3)-223 (x^4)+221 (x^5)-217 (x^6)+127 (x^7)-42 (x^8)+6 (x^9))/(((-1+x))^7)),{x,0,20}],x]

MinimumEdgeCoverCount

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimumEdgeCoverCount"],{n,20}]

MinimumVertexDegree

seq=Table[GraphData[{"RookComplement",{n,n}},"MinimumVertexDegree"],{n,20}]

FindSequenceFunction[seq,n]

MolecularTopologicalIndex

A292282

seq=Table[GraphData[{"RookComplement",{n,n}},"MolecularTopologicalIndex"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

seq=Table[2 (((-1+n))^3) (n^2) (1+n),{n,20}]

coef=FindLinearRecurrence[seq]

Take[seq,Length@coef]

LinearRecurrence[{7,-21,35,-35,21,-7,1},{0,24,576,4320,19200,63000,169344},30]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((24 x(1+17 x+33 (x^2)+9 (x^3)))/(((-1+x))^7)),{x,0,20}],x]

Nonhamiltonian

Table[GraphData[{"RookComplement",{n,n}},"Nonhamiltonian"],{n,20}]

NormalizedLaplacianMatrix

MatrixForm/@Table[GraphData[{"RookComplement",{n,n}},"NormalizedLaplacianMatrix"],{n,5}]

OddChordlessCycleCount

seq=Table[GraphData[{"RookComplement",{n,n}},"OddChordlessCycleCount"],{n,20}]

PathCount

A292391

seq=Table[GraphData[{"RookComplement",{n,n}},"PathCount"],{n,20}]

PentagonCount

A291911

seq=Table[GraphData[{"RookComplement",{n,n}},"PentagonCount"],{n,20}]

(seq=Table[CycleCount[System`GraphComplement[RookGraph[n,n]],5],{n,15}])//Timing

FindSequenceFunction[seq,n]//Factor

seq=Table[(((n-2))^2) (((n-1))^2) (n^2) (4+2 n+3 (n^2)-4 (n^3)+(n^4))/10,{n,30}]

coef=FindLinearRecurrence[seq]

Take[seq,Length@coef]

LinearRecurrence[{11,-55,165,-330,462,-462,330,-165,55,-11,1},{0,0,36,3456,77040,800640,5265540,25514496,99320256,327836160,951285060},30]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((36 (x^2) (1+85 x+1139 (x^2)+3815 (x^3)+3815 (x^4)+1139 (x^5)+85 (x^6)+(x^7)))/(((-1+x))^11)),{x,0,20}],x]

Perfect

Table[GraphData[{"RookComplement",{n,n}},"Perfect"],{n,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"ProjectivePlaneCrossingNumber"],{n,20}]

Radius

seq=Table[GraphData[{"RookComplement",{n,n}},"Radius"],{n,20}]

RankPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"RankPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"RectilinearCrossingNumber"],{n,20}]

ReliabilityPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"ReliabilityPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

SigmaPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"SigmaPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

Skewness

seq=Table[GraphData[{"RookComplement",{n,n}},"Skewness"],{n,20}]

FindSequenceFunction[Take[seq,7],n]

FindGeneratingFunction[Take[seq,7],x]

SpanningTreeCount

seq=Table[GraphData[{"RookComplement",{n,n}},"SpanningTreeCount"],{n,20}]

FindSequenceFunction[Take[seq,7],n]

FindGeneratingFunction[Take[seq,7],x]

SquareCount

A291910

seq=Table[GraphData[{"RookComplement",{n,n}},"SquareCount"],{n,20}]

FindSequenceFunction[seq,n]//Factor

seq=Table[(1/8) (-2+n) (((-1+n))^2) (n^2) (-4+5 n-4 (n^2)+(n^3)),{n,20}]

coef=FindLinearRecurrence[seq]

Take[seq,Length@coef]

LinearRecurrence[{9,-36,84,-126,126,-84,36,-9,1},{0,0,9,576,6900,44100,196245,686784,2023056},30]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((3 (x^2) (3+165 x+680 (x^2)+660 (x^3)+165 (x^4)+7 (x^5)))/(((-1+x))^9)),{x,0,20}],x]

StabilityIndex

seq=Table[GraphData[{"RookComplement",{n,n}},"StabilityIndex"],{n,20}]

FindSequenceFunction[seq,n]

FindGeneratingFunction[seq,x]

TopologicalIndex

seq=Table[GraphData[{"RookComplement",{n,n}},"TopologicalIndex"],{n,20}]

FindSequenceFunction[seq,n]

FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

seq=Table[GraphData[{"RookComplement",{n,n}},"ToroidalCrossingNumber"],{n,20}]

Traceable

Table[GraphData[{"RookComplement",{n,n}},"Traceable"],{n,20}]

TriangleCount

A179058

seq=Table[GraphData[{"RookComplement",{n,n}},"TriangleCount"],{n,20}]

FindSequenceFunction[seq,n]//Factor

seq=Table[3!((Binomial[n,3])^2),{n,20}]

3!((Binomial[Range[20],3])^2)

coef=FindLinearRecurrence[seq]

Take[seq,Length@coef]

LinearRecurrence[{7,-21,35,-35,21,-7,1},{0,0,6,96,600,2400,7350},20]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((6 (x^2) (1+9 x+9 (x^2)+(x^3)))/(((-1+x))^7)),{x,0,20}],x]

TuttePolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"TuttePolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

Untraceable

Table[GraphData[{"RookComplement",{n,n}},"Untraceable"],{n,20}]

VertexConnectivity

Table[GraphData[{"RookComplement",{n,n}},"VertexConnectivity"],{n,20}]

VertexCount

seq=Table[GraphData[{"RookComplement",{n,n}},"VertexCount"],{n,20}]

FindSequenceFunction[seq,n]

VertexCoverNumber

vertex cover number == vertex count - independence number

seq=Table[GraphData[{"RookComplement",{n,n}},"VertexCoverNumber"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

VertexCoverPolynomial

(poly=Factor[Table[GraphData[{"RookComplement",{n,n}},"VertexCoverPolynomial"],{n,k0=1,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>0]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

VertexDegrees

seq=Table[GraphData[{"RookComplement",{n,n}},"VertexDegrees"],{n,20}]

VertexTransitive

Table[GraphData[{"RookComplement",{n,n}},"VertexTransitive"],{n,20}]

WienerIndex

A292058

seq=Table[GraphData[{"RookComplement",{n,n}},"WienerIndex"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]//Factor

seq=Table[(n-1) (n^2) (n+3)/2,{n,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{5,-10,10,-5,1},{0,10,54,168,400},20]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((2 x (-5-2 x+(x^2)))/(((-1+x))^5)),{x,0,20}],x]

WienerSumIndex

seq=Table[GraphData[{"RookComplement",{n,n}},"WienerSumIndex"],{n,20}]

FindSequenceFunction[Drop[seq,2],n-2]

GraphData

<<MathWorld`Graphs`

GraphDataString

file=OpenAppend["~/rook-complement.m"]

WriteString[file,GraphDataString[GraphComplement[RookGraph@@#],
"StandardName"->{"RookComplement",#},
"Name"->"("<>IntegerString[#[[1]]]<>","<>IntegerString[#[[2]]]<>")\[Hyphen]rook complement graph",
"Embeddings"->{},
"Information"->"RookComplementGraph",
"Classes"->{"RookComplement"},
"NotationRules"->{"RookComplement"->#},
"Skip"->Join[
{"ABCEnergy","ABCSpectralRadius","Arboricity","ArcTransitivity","ArithmeticGeometricEnergy","ArithmeticGeometricSpectralRadius","BipartiteDoubleGraphName","Cactus","Chord","ChordlessCycles","Chords","CirculantIndices","CliqueCoveringNumber","ComplementChordlessCyclePolynomial","ComplementChordlessCycles","ComplementOddChordlessCyclePolynomial","ComplementOddChordlessCycles","ComplementOddChordlessCyclePolynomial","ConnectedDominatingSets","ConnectedInducedSubgraphs","ConnectedInducedSubgraphPolynomial","ConstructionNumber",
"CyclePolynomial","Cycles","CyclicEdgeConnectivity","EdgeChromaticNumber","EdgeCovers","EdgeCuts","EdgeBetweennessCentralities","FractionalEdgeChromaticNumber","GracefulLabeling","HadwigerNumber","HamiltonianCycles","HamiltonianPaths","HamiltonianWalks","IdiosyncraticPolynomial","IntersectionNumber","IrredundancePolynomial","LambdaComponents","LucioSamiComponents","LovaszNumber","MatchingGeneratingPolynomial","MatchingPolynomial","MaximalCliquePolynomial","MaximalCliques","MaximalIndependentEdgeSets","MinimumCostFlowMatrix","MaximumFlowMatrix","MaximumIndependentEdgeSetCount","MaximumIndependentEdgeSets","MetricDimension","Meyniel","MinimumCoveringsByMaximalCliques","MinimumCyclicEdgeCut","MinimumCyclicEdgeCuts","MinimumDistinguishingLabelings","MinimumEdgeColoring","MinimumPathCoverings","MinimumVertexCover","MinimumVertexCut","MinimumWeightFractionalEdgeColoring","Minors","OddChordlessCycle","OddChordlessCycles","PathPolynomial","PathSignature","ProjectivePlanar","RandicEnergy","RectilinearCrossingNumber","SomborEnergy","SomborSpectralRadius","UniquelyColorable","UniquelyHamiltonian","TotalDominationPolynomial","TuttePolynomial"},
If[#[[1]]==20,{"CrossingNumber","EmbeddingClasses"},{}]],
"Notation"->OverBar[Row[{Subscript["K",#[[1]]],"\[Square]",Subscript["K",#[[1]]]}]],
TimeConstraint->60,
Debug->True
]]&/@Table[{n,n},{n,{20}}];

Close[file]