Goldberg Snark

Author

Eric W. Weisstein
May 29, 2022

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

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

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

Standard names

Renamed from "GoldbergSnark5" to {"Goldberg", 5} etc. in V13.1

$Version

GraphData["Goldberg"]

GraphData["Goldberg*"]

GraphData[{"Goldberg","Snark"}]

Graphics

Renamed from "GoldbergSnark5" to {"Goldberg", 5} etc. in V13.1

GraphData

GraphicsRow[Table[GraphData[{"Goldberg",n}],{n,3,7}]//StyleGraphs,Dividers->All]

GraphicsGrid[Partition[Table[GraphData[{"Goldberg",n}],{n,3,20}]//StyleGraphs,UpTo[5]],Dividers->All,ImageSize->700]

Embeddings

<<MathWorld`Graphs`

{"Goldberg", 1} [contains  a self-loop]

GoldbergGraph[1,ImageSize->Small]//StyleGraphs

SimpleGraphQ[%]

{"Goldberg", 2} [contains  a self-loop]

GoldbergGraph[2,"Radii"->{1,1/2},ImageSize->Small]//StyleGraphs

SimpleGraphQ[%]

{"Goldberg", 3}

Graphs.m

g=GoldbergGraph[3,ImageSize->Small]//StyleGraphs

Pegg

Based on Ed Pegg Jr.
August 22, 2002 and September 13, 2006

Goldberg3 = ScaleGraph@Graph[Range[24],UndirectedEdge@@@{{10,9},{9,8},{9,13},{13,16},{16,15},{16,17},{10,17},{8,15},{7,5},{3,1},{2,1},{2,5},{4,2},{6,4},{6,7},{3,6},{20,18},{24,22},{19,22},{19,18},{21,19},{23,21},{23,20},{24,23},{7,15},{12,13},{1,10},{22,3},{11,4},{17,24},{14,21},{20,5},{8,18},{14,11},{12,14},{11,12}}, VertexCoordinates->{{10415,-8437},{11317,-7915},{11456,-10246},{11837,-8820},{12218,-7393},{12358,-9724},{13259,-9202},{15304,-2033},{15304,-989},{15304,55},{15444,-6732},{16346,-5165},{16346,-989},{17247,-6732},{17387,-2033},{17387,-989},{17387,55},{19432,-9202},{20333,-9724},{20473,-7393},{20854,-8820},{21235,-10246},{21374,-7915},{22276,-8437}}]

RecognizeGraph[Goldberg3]

Not a snark:

GraphGirth[Goldberg3]

GraphDataString[Goldberg3,{"GoldbergSnark3","Goldberg snark 3","GoldbergSnark"},TimeConstraint->15,Debug->True]

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Goldberg",3},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"Goldberg",3},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

DegenerateGraphEmbeddingTypes/@GraphData[{"Goldberg",3},"Graph","Degenerate"]//Union

Bilateral

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

Circular

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

Planar

GraphData[{"Goldberg",3},"Planar"]

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

MinimalCrossing

GraphData[{"Goldberg",3},{"RCN","CN"}]

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

MinimalCrossing construction

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

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

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

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

GraphPlot@RotateGraph[,{11,12}]

v={#/6,#2/7}&@@@{{0,0},{6,0},{3,1},{0,2},{1,2},{2,2},{4,2},{5,2},{6,2},{0,3},{2,3},{4,3},{6,3},{2,4},{4,4},{2,5},{3,5},{4,5},{1,6},{2,6},{4,6},{5,6},{0,7},{6,7}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,9,13,24,23,10,4,1,3,2],e[4,5,6,7,8,9],e[6,11,14,16,21],e[7,12,15,18,20],{10,11},{12,13},e[5,19,20,21,22,8],{14,15},{3,17},e[16,17,18],{19,23},{22,24}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

RectilinearCrossingCount@g

GraphPlot@RotateGraph[,{10,17}]

v={#/8,(#2+1)/7}&@@@{{0,-1},{8,-1},{2,0},{4,0},{6,0},{4,1},{1,2},{3,2},{5,2},{7,2},{2,3},{6,3},{2,4},{3,4},{5,4},{6,4},{1,5},{3,5},{5,5},{7,5},{0,6},{2,6},{6,6},{8,6}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,24,23,22,21,1,3,4,5,2],e[3,11,12,5],e[21,17,18,19,20,24],e[17,7,8,9,10,20],e[8,6,9],{4,6},e[7,13,14,12],e[10,16,15,11],{13,22},{14,18},{15,19},{16,23}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

RectilinearCrossingCount@g

GraphPlot@RotateGraph[,{1,3}]

v={#/6,#2/9}&@@@Join[{{0,0},{6,0},{3,1},{3,2}},Table[{1,j},{j,2,8}],Table[{5,j},{j,2,8}],{{2,8},{4,8},{0,9},{6,9},{2,4},{4,4}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[4,3,1,2,16],{2,3},e[1,9],e[5,21,22,12,4,5,6,7,8,9,10,11,19,20,18,17,16,15,14,13,12],{6,13},e[7,23,24,14],{8,19},{15,20},{10,23},{17,24},{21,18},{11,22}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

gs={,,};

RectilinearCrossingCount[g]

GraphPlot@MinimalCrossingGraph[GraphData[{"Goldberg",3}],"CrossingNumber"->5]

v={{5,-4},{4,-2},{6,-2},{6,-1},{0,0},{1,0},{2,0},{5,0},{6,0},{0,1},{2,1},{3,1},{5,1},{7,1},{8,1},{4,2},{4,3},{5,3},{6,3},{3+1/2,4},{4,4},{6,4},{8,4},{5,6}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,15,23,24,10,5,1],e[10,11,12,13,14,15],e[5,6,7,8,9],e[1,2,16,17,21],e[20,21,22,23],e[6,20,12],{7,11},e[17,18,19,22],{18,24},{13,16},e[3,4,9,19],{4,8},e[2,3,14]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"Goldberg",3},"Circulant"]

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

Halin

GraphData[{"Goldberg",3},"Halin"]

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

Rigid

GraphData[{"Goldberg",3},"Rigid"]

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

Flexible

GraphData[{"Goldberg",3},"Flexible"]

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

LCF

GraphData[{"Goldberg",3},"LCF"]

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

UnitDistance

GraphData[{"Goldberg",3},"UnitDistance"]

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Select[gs,!DegenerateGraphEmbeddingQ[#]&]//StyleGraphs

Matchstick

GraphData[{"Goldberg",3},"Matchstick"]

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

3D default

Graph3D[GraphData[{"Goldberg",3},"Edges"]]

3D All

GraphData[{"Goldberg",3},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Goldberg",3},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Goldberg",3},"Polyhedral"]

GraphData[{"Goldberg",3},"Graph",{"3D","Polyhedron"}]

{"Goldberg", 4}

Graphs.m

Primary

g=GoldbergGraph[4,ImageSize->Small]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

GraphPlot[GraphData[{"Goldberg",4},"Edges"],GraphLayout->"HighDimensionalEmbedding"]

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

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

GraphPlot@RotateGraph[,{25,21}]

v={#/9,#2/7}&@@@{{0,0},{9,0},{1,1},{3,1},{4,1},{5,1},{6,1},{8,1},{0,2},{3,2},{4-1/2,2},{5+1/2,2},{6,2},{9,2},{3,3},{6,3},{3,4},{6,4},{1,5},{2,5},{3,5},{6,5},{7,5},{8,5},{1,6},{3,6},{6,6},{8,6},{0,7},{2,7},{7,7},{9,7}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,14,32,31,30,29,9,1,3,4,5,6,7,8,2],e[29,25,26,27,28,32],e[25,19,20,21],e[22,23,24,28],{20,30},{23,31},e[4,10,15,17,21,26],e[7,13,16,18,22,27],{9,10},{13,14},e[5,11,19],e[6,12,24],{3,17},{8,18},{11,12},{15,16}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@RotateGraph[,{5,9}]

v={#/9,#2/8}&@@@{{0,0},{9,0},{4,1},{5,1},{4,2},{5,2},{3,3},{4,3},{5,3},{6,3},{0,4},{4,4},{5,4},{9,4},{3,5},{4,5},{5,5},{6,5},{1,6},{2,6},{3,6},{6,6},{7,6},{8,6},{1,7},{3,7},{6,7},{8,7},{0,8},{2,8},{7,8},{9,8}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,14,32,31,30,29,11,1,7,8,5,3,4,6,9,10,2],e[11,12,8],e[14,13,9],e[7,15,21,26],e[10,18,22,27],e[3,19,25,26,27,28,24,4],{5,6},{20,30},{23,31},e[19,20,21],e[22,23,24],e[15,16,17,18],{12,16},{13,17},{29,25},{28,32}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

gs={,};

Circulant

GraphData[{"Goldberg",4},"Circulant"]

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

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

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

lcf

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding original

l=FindSubgraphIsomorphism[GraphData[{"Goldberg",4}],"Results"->All]//Timing

gs=UniqueEmbeddings[l]

UnitDistance by FindSubgraphUnitDistanceEmbedding redo

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Goldberg", 5}

Graphs.m

g=GoldbergGraph[5,ImageSize->Small]//StyleGraphs

Pegg

Based on Ed Pegg Jr.
August 22, 2002
September 13, 2006

Goldberg5=ScaleGraph@Graph[Range[40],UndirectedEdge@@@{{16,15},{15,14},{15,21},{21,26},{26,25},{26,27},{16,27},{14,25},{7,10},{6,2},{6,10},{4,6},{3,4},{3,7},{1,3},{1,2},{17,9},{8,5},{8,9},{11,8},{13,11},{13,17},{12,13},{12,5},{32,24},{28,29},{28,24},{30,28},{33,30},{33,32},{36,33},{36,29},{31,34},{38,40},{38,34},{37,38},{35,37},{35,31},{39,35},{39,40},{2,16},{7,25},{17,10},{5,1},{32,9},{29,12},{31,24},{40,36},{14,34},{27,39},{20,21},{18,4},{19,11},{22,30},{23,37},{22,19},{23,22},{20,23},{18,20},{19,18}},VertexCoordinates->{{10945,-4657},{11604,-2623},{11959,-4987},{12289,-3970},{12349,-8989},{12618,-2953},{12973,-5318},{12976,-8124},{13602,-7259},{13633,-3284},{13838,-8752},{14074,-10246},{14701,-9381},{15279,-2084},{15279,-1015},{15279,55},{15328,-8516},{15331,-4962},{15719,-6157},{16346,-4223},{16346,-1015},{16972,-6157},{17360,-4962},{17363,-8516},{17412,-2084},{17412,-1015},{17412,55},{17990,-9381},{18617,-10246},{18853,-8752},{19059,-3284},{19089,-7259},{19715,-8124},{19718,-5318},{20073,-2953},{20342,-8989},{20402,-3970},{20732,-4987},{21087,-2623},{21746,-4657}}]

RecognizeGraph[Goldberg5]

Snark:

EdgeChromaticNumber[Goldberg5]

GraphGirth[Goldberg5]

GraphDataString[Goldberg5,{"GoldbergSnark5","Goldberg snark 5","GoldbergSnark"},TimeConstraint->15,Debug->True]

Primary

g=GoldbergGraph[5,ImageSize->Small]//StyleGraphs

All

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

Inexact

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

Embedding types

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

Default embedding

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

g=GoldbergGraph[5]

RecognizeGraph[g]

Degenerate

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

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

Bilateral

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

Circular

GraphData[{"Goldberg",5},"Graph","Circular"]

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

GraphPlot@RotateGraph[,{23,20}]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@RotateGraph[,{40,39}]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

UnitDistance

UnitDistanceGraphQ[GraphData[{"Goldberg",5}],Debug->True]

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",5},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Goldberg",5},"EdgeList"]]]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

l=FindSubgraphIsomorphism[GraphData[{"Goldberg",5}],"Results"->All]//Timing

gs=UniqueEmbeddings[l]

Matchstick

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

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

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

3D

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

{"Goldberg", 6}

Graphs.m

GoldbergGraph[6,ImageSize->Small]//StyleGraphs

All

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

LCF

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

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

LCFGraph@@@GraphData[{"Goldberg",6},"LCFNotations"]

UnitDistance

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

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",6},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

{{"Goldberg",6},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",6}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

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

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

3D

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

Default embedding

g=Graph@GraphData[{"Goldberg",6},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing Construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",6}],"CrossingNumber"->12]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

{"Goldberg", 7}

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

All

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

LCF

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

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

UnitDistance

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

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",7},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

{{"Goldberg",7},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",7}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

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

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

3D

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

Default embedding

g=Graph@GraphData[{"Goldberg",7},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing Construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",7}],"CrossingNumber"->14]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

{"Goldberg", 8}

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

Graphs.m

GoldbergGraph[8,ImageSize->Small]//StyleGraphs

All

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

Halin

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

LCF

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

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

UnitDistance

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

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",8},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",8},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",8}],TimeConstraint->500,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

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

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

Default embedding

g=Graph@GraphData[{"Goldberg",8},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing Construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",8}]]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

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

3D All

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

3D Polyhedron

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Goldberg",8},"Polyhedron"]}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Goldberg",8},"Polyhedron"],Yellow,Sphere[]}]

3D Polyhedron construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Goldberg",8}],1]}]

gn={"Goldberg",8};
g=Graph3D[Range@GraphData[gn,"V"],GraphData[gn,"Edges"],GraphLayout->"HighDimensionalEmbedding",VertexLabels->Automatic]

v=GraphEmbedding[g];

g1=Graph[Range[10],EdgeList[g],VertexCoordinates->ReplacePart[v,10->v[[10]]+.5{1,1,1}]]
v=GraphEmbedding[g1];

v0=Mean[v];
f=GraphData[gn,"FaceIndices"];
Graphics3D[{FaceForm[Green,Red],poly=Polyhedron[(#-v0)&/@v,f]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->5000,PrecisionGoal->20])//Timing

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

SimplePolyhedronQ[can]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Goldberg", 9}

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

All

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

Halin

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

LCF

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

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

UnitDistance

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

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",9},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

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

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

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

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

Default embedding

g=Graph@GraphData[{"Goldberg",9},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing Construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",9}],"CrossingNumber"->18]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

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

3D All

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

3D UnitDistance

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

{"Goldberg", 10}

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

All

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

Graphs.m

GoldbergGraph[10,ImageSize->Small]//StyleGraphs

Halin

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

LCF

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

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

UnitDistance

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

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",10},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",10},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",10}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",10}],"CrossingNumber"->20]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

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

3D All

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

3D UnitDistance

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

{"Goldberg", 11}

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

All

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

Halin

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

LCF

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

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

UnitDistance

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

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",11},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",11},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",11}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",11}],"CrossingNumber"->22]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Goldberg", 12}

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

All

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

Graphs.m

GoldbergGraph[12,ImageSize->Small]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

Halin

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

LCF

GraphData[{"Goldberg",12},"LCFSignature"]

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

UnitDistance

GraphData[{"Goldberg",12},"UnitDistance"]

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",12},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

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

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

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

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

Default embedding

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

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",12}],"CrossingNumber"->-1]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",12},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Goldberg",12},"Polyhedron"]}]

3D Canonical

GraphData[{"Goldberg",12},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Goldberg",12},"Polyhedron"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Goldberg",12}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->1000,MaxIterations->10000,PrecisionGoal->20])//Timing

SimplePolyhedronQ[can]

If[%===False,Quit[]]

Graphics3D[{Opacity[.5],Red,can,Yellow,Sphere[]}]

(lens=Mean/@Split[Sort[PolyhedronEdgeLengths[can]],Abs[#1-#2]<1.*^-10&])//N

v=PolyhedronCoordinates[can];

colors=With[{n=Length[lens]},Table[Hue[i/n],{i,0,n-1}]]

Graphics3D[{Thick,Sequence@@Nearest[Thread[lens->colors],EuclideanDistance@@v[[#]]],Line[v[[#]]]}&/@PolyhedronEdges[can],Boxed->False]

g=PolyhedronGraph[can]

{"Goldberg", 13}

GraphData[{"Goldberg",13},"StandardName"]

All

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

Halin

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

LCF

GraphData[{"Goldberg",13},"LCFSignature"]

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

UnitDistance

GraphData[{"Goldberg",13},"UnitDistance"]

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",13},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",13},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",13}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

GraphData[{"Goldberg",13},{"RCN","CN"}]

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

Default embedding

GraphPlot@GraphData[{"Goldberg",13},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",13}],"CrossingNumber"->26]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",13},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Goldberg",13},"Polyhedral"]

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Goldberg",13},"Polyhedron"]}]

{"Goldberg", 14}

GraphData[{"Goldberg",14},"StandardName"]

Graphs.m

GoldbergGraph[14,ImageSize->Small]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

All

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

Halin

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

LCF

GraphData[{"Goldberg",14},"LCFSignature"]

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

UnitDistance

GraphData[{"Goldberg",14},"UnitDistance"]

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",14},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

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

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

GraphData[{"Goldberg",14},{"RCN","CN"}]

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

Default embedding

GraphPlot@GraphData[{"Goldberg",14},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",14}],"CrossingNumber"->28]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",14},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Goldberg",14},"Polyhedral"]

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Goldberg",14},"Polyhedron"]}]

{"Goldberg", 15}

GraphData[{"Goldberg",15},"StandardName"]

All

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

Halin

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

LCF

GraphData[{"Goldberg",15},"LCFSignature"]

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

UnitDistance

GraphData[{"Goldberg",15},"UnitDistance"]

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

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

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",15},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

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

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

GraphData[{"Goldberg",15},{"RCN","CN"}]

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

Default embedding

GraphPlot@GraphData[{"Goldberg",15},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",15}],"CrossingNumber"->30]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",15},"Edges"]]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

{"Goldberg", 16}

Graphs.m

GoldbergGraph[16,ImageSize->Small]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

All

GraphData[{"Goldberg",16},"Graph","All"]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

LCF

GraphData[{"Goldberg",16},"Graph","LCF"]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

UnitDistance

GraphData[{"Goldberg",16},"UnitDistance"]

GraphData[{"Goldberg",16},"Graph","UnitDistance"]//StyleGraphs

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",16},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",16}],"Results"->All]//Timing

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",16},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",16}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"Goldberg",16},"Graph","Matchstick"]//StyleGraphs

MinimalCrossing

GraphData[{"Goldberg",16},{"RCN","CN"}]

GraphData[{"Goldberg",16},"Graph","MinimalCrossing"]//StyleGraphs

Default embedding

GraphPlot@GraphData[{"Goldberg",16},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",16}],"CrossingNumber"->32]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",16},"Edges"]]

3D All

GraphData[{"Goldberg",16},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Goldberg",16},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Goldberg",16},"Graph",{"3D","Polyhedron"}]

{"Goldberg", 17}

GraphData[{"Goldberg",17},"StandardName"]

All

GraphData[{"Goldberg",17},"Graph","All"]//StyleGraphs

Halin

GraphData[{"Goldberg",17},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"Goldberg",17},"LCFSignature"]

GraphData[{"Goldberg",17},"Graph","LCF"]//StyleGraphs

UnitDistance

GraphData[{"Goldberg",17},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Goldberg",17}],Debug->True]//Timing

GraphData[{"Goldberg",17},"Graph","UnitDistance"]//StyleGraphs

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",17},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",17},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",17}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"Goldberg",17},"Graph","Matchstick"]//StyleGraphs

MinimalCrossing

GraphData[{"Goldberg",17},{"RCN","CN"}]

GraphData[{"Goldberg",17},"Graph","MinimalCrossing"]//StyleGraphs

Default embedding

GraphPlot@GraphData[{"Goldberg",17},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",17}],"CrossingNumber"->34]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",17},"Edges"]]

3D All

GraphData[{"Goldberg",17},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Goldberg",17},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Goldberg",17},"Graph",{"3D","Polyhedron"}]

{"Goldberg", 18}

Graphs.m

GoldbergGraph[18,ImageSize->Small]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

All

GraphData[{"Goldberg",18},"Graph","All"]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

LCF

GraphData[{"Goldberg",18},"Graph","LCF"]//StyleGraphs[#,VertexSize->{"Scaled",.015}]&

UnitDistance

GraphData[{"Goldberg",18},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Goldberg",18}],Debug->True]//Timing

GraphData[{"Goldberg",18},"Graph","UnitDistance"]//StyleGraphs

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",18},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",18},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",18}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"Goldberg",18},"Graph","Matchstick"]//StyleGraphs

MinimalCrossing

GraphData[{"Goldberg",18},{"RCN","CN"}]

GraphData[{"Goldberg",18},"Graph","MinimalCrossing"]//StyleGraphs

Default embedding

GraphPlot@GraphData[{"Goldberg",18},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",18}],"CrossingNumber"->36]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",18},"Edges"]]

3D All

GraphData[{"Goldberg",18},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Goldberg",18},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Goldberg",18},"Graph",{"3D","Polyhedron"}]

"Foster150A"

"Foster150A"

{"Goldberg", 19}

GraphData[{"Goldberg",19},"StandardName"]

All

GraphData[{"Goldberg",19},"Graph","All"]//StyleGraphs

Halin

GraphData[{"Goldberg",19},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"Goldberg",19},"LCFSignature"]

GraphData[{"Goldberg",19},"Graph","LCF"]//StyleGraphs

UnitDistance

GraphData[{"Goldberg",19},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Goldberg",19}],Debug->True]//Timing

GraphData[{"Goldberg",19},"Graph","UnitDistance"]//StyleGraphs

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",19},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",19},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",19}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"Goldberg",19},"Graph","Matchstick"]//StyleGraphs

MinimalCrossing

GraphData[{"Goldberg",19},{"RCN","CN"}]

GraphData[{"Goldberg",19},"Graph","MinimalCrossing"]//StyleGraphs

Default embedding

GraphPlot@GraphData[{"Goldberg",19},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",19}],"CrossingNumber"->38]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",19},"Edges"]]

3D All

GraphData[{"Goldberg",19},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Goldberg",19},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Goldberg",19},"Graph",{"3D","Polyhedron"}]

{"Goldberg", 20}

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

All

GraphData[{"Goldberg",20},"Graph","All"]//StyleGraphs

Halin

GraphData[{"Goldberg",20},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"Goldberg",20},"LCFSignature"]

GraphData[{"Goldberg",20},"Graph","LCF"]//StyleGraphs

UnitDistance

GraphData[{"Goldberg",20},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"Goldberg",20}],Debug->True]//Timing

GraphData[{"Goldberg",20},"Graph","UnitDistance"]//StyleGraphs

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Goldberg",20},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"Goldberg",20},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"Goldberg",20}],TimeConstraint->300,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"Goldberg",20},"Graph","Matchstick"]//StyleGraphs

MinimalCrossing

GraphData[{"Goldberg",20},{"RCN","CN"}]

GraphData[{"Goldberg",20},"Graph","MinimalCrossing"]//StyleGraphs

Default embedding

GraphPlot@GraphData[{"Goldberg",20},"Edges"]

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

RecognizeGraph[g]

MinimalCrossing construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Goldberg",20}],"CrossingNumber"->41]]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

3D default

Graph3D[GraphData[{"Goldberg",20},"Edges"]]

3D All

GraphData[{"Goldberg",20},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"Goldberg",20},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"Goldberg",20},"Graph",{"3D","Polyhedron"}]

Snark status

TextGrid[
Prepend[
Prepend[GraphData[#,{"V","Snark","#","Cubic","Class2","EdgeChromaticNumber"}],GraphData[#,"NotationRules","Goldberg"]]&/@GraphData["Goldberg"],
Thread[Style[{"n","V","snark","name","cubic","class 2","ECN"},Bold]
]
],Dividers->All,Alignment->{{Decimal,Decimal,{Left}}}]

Properties

Acyclic

Table[GraphData[{"Goldberg",n},"Acyclic"],{n,3,20}]//Union

AdjacencyMatrixCount

seq=Table[GraphData[{"Goldberg",n},"AdjacencyMatrixCount"],{n,3,20}]

AlgebraicConnectivity

seq=Table[GraphData[{"Goldberg",n},"AlgebraicConnectivity"],{n,3,20}]

AlmostHamiltonian

Table[GraphData[{"Goldberg",n},"AlmostHamiltonian"],{n,3,20}]

Anarboricity

seq=Table[GraphData[{"Goldberg",n},"Anarboricity"],{n,3,20}]

Antipodal

Table[GraphData[{"Goldberg",n},"Antipodal"],{n,3,20}]//Union

Apex

Table[GraphData[{"Goldberg",n},"Apex"],{n,3,20}]//Union

ApexCount

seq=Table[GraphData[{"Goldberg",n},"ApexCount"],{n,3,20}]

Arboricity

Table[GraphData[{"Goldberg",n},"Arboricity"],{n,3,20}]

ArcTransitive

Table[GraphData[{"Goldberg",n},"ArcTransitive"],{n,3,20}]//Union

ArcTransitivity

Table[GraphData[{"Goldberg",n},"ArcTransitivity"],{n,3,20}]//Union

ArticulationVertexCount

seq=Table[GraphData[{"Goldberg",n},"ArticulationVertexCount"],{n,3,20}]

AutomorphismCount

seq=Table[GraphData[{"Goldberg",n},"AutomorphismCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

BalabanIndex

seq=Table[GraphData[{"Goldberg",n},"BalabanIndex"],{n,3,20}]

Bandwidth

Table[GraphData[{"Goldberg",n},"Bandwidth"],{n,3,20}]

Bicolorable

Table[GraphData[{"Goldberg",n},"Bicolorable"],{n,3,20}]//Union

Biconnected

Table[GraphData[{"Goldberg",n},"Biconnected"],{n,3,20}]//Union

Bicubic

Table[GraphData[{"Goldberg",n},"Bicubic"],{n,3,20}]//Union

Bipartite

Table[GraphData[{"Goldberg",n},"Bipartite"],{n,3,20}]//Union

BipartiteDimension

seq=Table[GraphData[{"Goldberg",n},"BipartiteDimension"],{n,3,20}]

Biplanar

2+Position[Table[GraphData[{"Goldberg",n},"Biplanar"],{n,3,20}],True]//Flatten

BlockCount

seq=Table[GraphData[{"Goldberg",n},"BlockCount"],{n,3,20}]

BridgeCount

seq=Table[GraphData[{"Goldberg",n},"BridgeCount"],{n,3,20}]

Bridged

Table[GraphData[{"Goldberg",n},"Bridged"],{n,3,20}]//Union

BroadcastTime

seq=Table[GraphData[{"Goldberg",n},"BroadcastTime"],{n,3,20}]

BurningNumber

seq=Table[GraphData[{"Goldberg",n},"BurningNumber"],{n,3,20}]

CharacteristicPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"CharacteristicPolynomial"][x],{n,k0=3,20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]//Head//Timing

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[(((-1-x))^(-1+n)) (-1+n-x),{n,k0,20}]

FullSimplify[poly2-poly]

CheegerConstant

seq=Table[GraphData[{"Goldberg",n},"CheegerConstant"],{n,3,20}]

Chordal

Table[GraphData[{"Goldberg",n},"Chordal"],{n,3,20}]//Union

ChordCount

seq=Table[GraphData[{"Goldberg",n},"ChordCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Factor

ChordlessCycleCount

seq=Table[GraphData[{"Goldberg",n},"ChordlessCycleCount"],{n,3,20}]

ChromaticInvariant

seq=Table[GraphData[{"Goldberg",n},"ChromaticInvariant"],{n,3,20}]

FindSequenceFunction[Drop[seq,2],n-2]

ChromaticNumber

seq=Table[GraphData[{"Goldberg",n},"ChromaticNumber"],{n,3,20}]

ChromaticPolynomial

poly=Table[GraphData[{"Goldberg",n},"ChromaticPolynomial"],{n,3,20}]/.f_Function:>f[x]

FindSequenceFunction[seq,n-4]

CircuitRank

seq=Table[GraphData[{"Goldberg",n},"CircuitRank"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

Circumference

seq=Table[GraphData[{"Goldberg",n},"Circumference"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Classes

Intersection@@(GraphData[#,"Classes"]&/@GraphData["Goldberg"])

ClawFree

Table[GraphData[{"Goldberg",n},"ClawFree"],{n,3,20}]//Union

CliqueCount

seq=Table[GraphData[{"Goldberg",n},"CliqueCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

gf=(x^3)FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]

CliqueCoveringNumber

seq=Table[GraphData[{"Goldberg",n},"CliqueCoveringNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

CliqueNumber

seq=Table[GraphData[{"Goldberg",n},"CliqueNumber"],{n,3,20}]

CliquePolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"CliquePolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x])//Column

FindLinearRecurrence[Rest@poly]

RSolve[{a[4]==1+32 x+48 (x^2),a[5]==1+40 x+60 (x^2),a[n]==2a[n-1]-a[n-2]},a[n],n]

Coarseness

seq=Table[GraphData[{"Goldberg",n},"Coarseness"],{n,3,20}]

CoboundaryPolynomial

seq=Table[GraphData[{"Goldberg",n},"CoboundaryPolynomial"],{n,3,20}]

ComplementOddChordlessCycleCount

Computed for n<=11; inferred beyond

seq=Table[GraphData[{"Goldberg",n},"ComplementOddChordlessCycleCount"],{n,3,20}]

ComplementOddChordlessCyclePolynomial

Computed for n<=11; inferred beyond

poly=(Table[GraphData[{"Goldberg",n},"ComplementOddChordlessCyclePolynomial"],{n,3,20}]/.f_Function:>f[x])

Conductance

seq=Table[GraphData[{"Goldberg",n},"Conductance"],{n,3,20}]

Connected

Table[GraphData[{"Goldberg",n},"Connected"],{n,3,20}]//Union

ConnectedComponentCount

seq=Table[GraphData[{"Goldberg",n},"ConnectedComponentCount"],{n,3,20}]

ConnectedDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"ConnectedDominatingSetCount"],{n,3,20}]

ConnectedDominationNumber

seq=Table[GraphData[{"Goldberg",n},"ConnectedDominationNumber"],{n,3,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedDominationPolynomial

(poly=DeleteCases[Factor@Table[GraphData[{"Goldberg",n},"ConnectedDominationPolynomial"][x],{n,k0=2,6}],_Missing[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,3,20}]

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

seq=Table[GraphData[{"Goldberg",n},"ConnectedInducedSubgraphCount"],{n,3,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedInducedSubgraphPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"ConnectedInducedSubgraphPolynomial"],{n,k0=3,kmax=20}]/.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,3,20}]

FullSimplify[poly2-poly]

Corank

seq=Table[GraphData[{"Goldberg",n},"Corank"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

CriticalNonplanar

Table[GraphData[{"Goldberg",n},"CriticalNonplanar"],{n,3,20}]//Union

CrossingNumber

seq=Table[GraphData[{"Goldberg",n},"CrossingNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

Cubic

Table[GraphData[{"Goldberg",n},"CriticalNonplanar"],{n,3,20}]//Union

CycleCount

seq=Table[GraphData[{"Goldberg",n},"CycleCount"],{n,3,20}]

Do[Print[{k,FindLinearRecurrence[Drop[seq,k]]//Head//Timing}],{k,0,3}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

CyclePolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"CyclePolynomial"],{n,k0=3,20}]/.f_Function:>f[x])//Column

FindLinearRecurrence[DeleteMissing@poly]//Head//Timing

FindGeneratingFunction[DeleteMissing@poly,z]//Head//Timing

Cyclic

Table[GraphData[{"Goldberg",n},"Cyclic"],{n,3,20}]//Union

Degeneracy

seq=Table[GraphData[{"Goldberg",n},"Degeneracy"],{n,3,20}]

DegreeCentralities

Tally/@Table[GraphData[{"Goldberg",n},"DegreeCentralities"],{n,3,20}]//Column

DetourIndex

seq=Table[GraphData[{"Goldberg",n},"DetourIndex"],{n,3,20}]

FindSequenceFunction[seq,n-4]//Factor

DetourPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"DetourPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

poly2=Table[(((n-1)^2-#) (#+n-1)^(n-1)&)@x,{n,k0,20}]

Abs[FullSimplify[poly2/poly]]

Diameter

seq=Table[GraphData[{"Goldberg",n},"Diameter"],{n,3,20}]

Dimension

seq=Table[GraphData[{"Goldberg",n},"Dimension"],{n,3,20}]

DistancePolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"DistancePolynomial"],{n,k0=3,kmax=20}]/.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]

Table[n x(3x+2)-2x^2+1,{n,10}]

FullSimplify[%-poly]

DistanceRegular

Table[GraphData[{"Goldberg",n},"DistanceRegular"],{n,3,20}]//Union

DistanceTransitive

Table[GraphData[{"Goldberg",n},"DistanceTransitive"],{n,3,20}]//Union

DistinguishingNumber

seq=Table[GraphData[{"Goldberg",n},"DistinguishingNumber"],{n,3,20}]

DomaticNumber

seq=Table[GraphData[{"Goldberg",n},"DomaticNumber"],{n,3,20}]

DominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"DominatingSetCount"],{n,3,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-4]

DominationNumber

Close to A195167 but may differ at term 26 etc.

seq=Table[GraphData[{"Goldberg",n},"DominationNumber"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

gf=(x^3)FindGeneratingFunction[DeleteMissing@seq,x]

SeriesCoefficient[gf,{x,0,n}]//FullSimplify

FullSimplify[(1/5) (2+11 n-Cos[((2 n π)/5)]-Cos[((4 n π)/5)]+(Sqrt[1+(2/(Sqrt[5]))]) Sin[((2 n π)/5)]+(1/20) (Sqrt[50-22 (Sqrt[5])]) (5+(Sqrt[5])) Sin[((4 n π)/5)]),n∈Integers]

Table[3n-Floor[((n GoldenRatio)/2)],{n,50}]

seq=Table[(1/5) (2+11 n-Cos[((2 n π)/5)]-Cos[((4 n π)/5)]+(Sqrt[1+(2/(Sqrt[5]))]) Sin[((2 n π)/5)]+(1/20) (Sqrt[50-22 (Sqrt[5])]) (5+(Sqrt[5])) Sin[((4 n π)/5)]),{n,70}]//FullSimplify

FindLinearRecurrence[seq]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

SeriesCoefficient[gf,{x,0,n}]//FullSimplify

Table[3n-Floor[((n GoldenRatio)/2)],{n,50}]-LinearRecurrence[{1,0,0,0,1,-1},{3,5,7,9,11,14},50]

Position[%,-1]//Flatten

FindLinearRecurrence[{3,5,7,9,11,14,16,18,20,22,25,27,29,31,33,36,38,40,42,44,47,49,51,53,55,57,60,62,64,66,68,71,73,75,77,79,82,84,86,88,90,93,95,97,99,101,103,106,108,110,112,114,117,119,121,123,125,128,130,132,134,136}]

DominationPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"DominationPolynomial"],{n,k0=3,kmax=20}]/.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[-1+(((1+x))^n),{n,k0,20}]

FullSimplify[poly2-poly]

Doublecross

Table[GraphData[{"Goldberg",n},"Doublecross"],{n,3,20}]//Union

Eccentricities

Tally/@Table[GraphData[{"Goldberg",n},"Eccentricities"],{n,3,20}]

EccentricityCentralities

Tally/@Table[GraphData[{"Goldberg",n},"EccentricityCentralities"],{n,3,20}]//Column

EdgeChromaticNumber

seq=Table[GraphData[{"Goldberg",n},"EdgeChromaticNumber"],{n,3,20}]

EdgeConnectivity

Table[GraphData[{"Goldberg",n},"EdgeConnectivity"],{n,3,20}]

EdgeCount

seq=Table[GraphData[{"Goldberg",n},"EdgeCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

EdgeCoverCount

seq=Table[GraphData[{"Goldberg",n},"EdgeCoverCount"],{n,3,20}]

EdgeCoverNumber

seq=Table[GraphData[{"Goldberg",n},"EdgeCoverNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

EdgeCoverPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"EdgeCoverPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

EdgeTransitive

Table[GraphData[{"Goldberg",n},"EdgeTransitive"],{n,3,20}]//Union

EigenvectorCentralities

Tally/@Table[GraphData[{"Goldberg",n},"EigenvectorCentralities"],{n,3,20}]//Column

EulerianCycleCount

seq=Table[GraphData[{"Goldberg",n},"EulerianCycleCount"],{n,3,20}]

FaceCount

seq=Table[GraphData[{"Goldberg",n},"FaceCount"],{n,3,20}]

FlowPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"FlowPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

FractionalArboricity

seq=Table[GraphData[{"Goldberg",n},"FractionalArboricity"],{n,3,20}]

FractionalChromaticNumber

seq=Table[GraphData[{"Goldberg",n},"FractionalChromaticNumber"],{n,3,20}]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"Goldberg",n},"FractionalEdgeChromaticNumber"],{n,3,20}]

Genus

seq=Table[GraphData[{"Goldberg",n},"Genus"],{n,3,20}]

Geodetic

Table[GraphData[{"Goldberg",n},"Geodetic"],{n,3,20}]//Union

Girth

seq=Table[GraphData[{"Goldberg",n},"Girth"],{n,3,20}]

GlobalClusteringCoefficient

Table[GraphData[{"Goldberg",n},"GlobalClusteringCoefficient"],{n,3,20}]

Gonality

seq=Table[GraphData[{"Goldberg",n},"Gonality"],{n,3,20}]

Graceful

Table[GraphData[{"Goldberg",n},"Graceful"],{n,3,20}]

GracefulLabelingCount

seq=Table[GraphData[{"Goldberg",n},"GracefulLabelingCount"],{n,3,20}]

HamiltonConnected

Table[GraphData[{"Goldberg",n},"HamiltonConnected"],{n,3,20}]

HamiltonDecomposable

Table[GraphData[{"Goldberg",n},"HamiltonDecomposable"],{n,3,20}]

HamiltonDecompositionCount

seq=Table[GraphData[{"Goldberg",n},"HamiltonDecompositionCount"],{n,3,20}]

Hamiltonian

Table[GraphData[{"Goldberg",n},"Hamiltonian"],{n,3,20}]

HamiltonianCycleCount

seq=Table[GraphData[{"Goldberg",n},"HamiltonianCycleCount"],{n,3,20}]

HamiltonianNumber

seq=Table[GraphData[{"Goldberg",n},"HamiltonianNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Table[(1/2) (16 n+1-(((-1))^n)),{n,3,20}]

HamiltonianPathCount

seq=Table[GraphData[{"Goldberg",n},"HamiltonianPathCount"],{n,3,20}]

FindSequenceFunction[Drop[seq,1],n-1]

HamiltonianWalkCount

seq=Table[GraphData[{"Goldberg",n},"HamiltonianWalkCount"],{n,3,20}]

HamiltonLaceable

Table[GraphData[{"Goldberg",n},"HamiltonianWalkCount"],{n,3,20}]

HararyIndex

seq=Table[GraphData[{"Goldberg",n},"HararyIndex"],{n,3,20}]

FindLinearRecurrence[seq]//Head//Timing

FindSequenceFunction[seq,n-2]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

HexagonCount

seq=Table[GraphData[{"Goldberg",n},"HexagonCount"],{n,3,20}]

HosoyaIndex

seq=Table[GraphData[{"Goldberg",n},"HosoyaIndex"],{n,3,20}]

FindLinearRecurrence[DeleteMissing@seq]//Head//Timing

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

HStarConnected

Table[GraphData[{"Goldberg",n},"HStarConnected"],{n,3,20}]

Hypohamiltonian

Table[GraphData[{"Goldberg",n},"Hypohamiltonian"],{n,3,20}]//Union

Hypotraceable

Table[GraphData[{"Goldberg",n},"Hypotraceable"],{n,3,20}]//Union

Identity

Table[GraphData[{"Goldberg",n},"Identity"],{n,3,20}]//Union

IdiosyncraticPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"IdiosyncraticPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x,y])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@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[(x+1)^(n-1) (x+1-n),{n,k0,10}]

FullSimplify[poly2/poly]

IndependenceNumber

seq=Table[GraphData[{"Goldberg",n},"IndependenceNumber"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//FullSimplify

gf=(x^3)FindGeneratingFunction[DeleteMissing@seq,x]

SeriesCoefficient[gf,{x,0,n}]

Table[(1/4) (-1+(((-1))^n)+14 n),{n,3,20}]

IndependencePolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"IndependencePolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@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[n x+1,{n,l0=10}]

FullSimplify[poly2-poly]

IndependenceRatio

seq=Table[GraphData[{"Goldberg",n},"IndependenceRatio"],{n,3,20}]

FullSimplify[FindSequenceFunction[DeleteMissing@seq,n-2],n∈Integers]

Table[((-1+(((-1))^n)+14 n)/(32 n)),{n,3,20}]

IndependentEdgeSetCount

seq=Table[GraphData[{"Goldberg",n},"IndependentEdgeSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

IndependentVertexSetCount

seq=Table[GraphData[{"Goldberg",n},"IndependentVertexSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

IntersectionNumber

seq=Table[GraphData[{"Goldberg",n},"IntersectionNumber"],{n,3,20}]

IrredundanceNumber

seq=Table[GraphData[{"Goldberg",n},"IrredundanceNumber"],{n,3,20}]

IrredundancePolynomial

poly=Table[GraphData[{"Goldberg",n},"IrredundancePolynomial"],{n,3,20}]/.f_Function:>f[x]

IrredundantSetCount

seq=Table[GraphData[{"Goldberg",n},"IrredundantSetCount"],{n,3,20}]

IsolatedPointCount

seq=Table[GraphData[{"Goldberg",n},"IsolatedPointCount"],{n,3,20}]

KatzCentralities

Tally/@Table[GraphData[{"Goldberg",n},"KatzCentralities"]/.f_Function:>f[x,y],{n,3,20}]//Column

KirchhoffIndex

seq=Table[GraphData[{"Goldberg",n},"KirchhoffIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

KirchhoffSumIndex

seq=Table[GraphData[{"Goldberg",n},"KirchhoffSumIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

LaplacianPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"LaplacianPolynomial"][x],{n,k0=1,10}])//Column

LeafCount

seq=Table[GraphData[{"Goldberg",n},"LeafCount"],{n,3,20}]

Likelihood

seq=Table[GraphData[{"Goldberg",n},"Likelihood"],{n,3,20}]

LinearArboricity

seq=Table[GraphData[{"Goldberg",n},"LinearArboricity"],{n,3,20}]

LocalClusteringCoefficients

Tally/@Table[GraphData[{"Goldberg",n},"LocalClusteringCoefficients"],{n,3,20}]

LongestCycleCount

seq=Table[GraphData[{"Goldberg",n},"LongestCycleCount"],{n,3,20}]

LongestPathCount

seq=Table[GraphData[{"Goldberg",n},"LongestPathCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head

LongestPathLength

seq=Table[GraphData[{"Goldberg",n},"LongestPathLength"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

LovaszNumber

seq=Table[GraphData[{"Goldberg",n},"LovaszNumber"],{n,3,20}]

LowerIndependenceNumber

Looks like A195167

Also agrees with A187477

seq=Table[GraphData[{"Goldberg",n},"LowerIndependenceNumber"],{n,3,20}]

With[{c=GoldenRatio},Table[3n-Floor[c n/2],{n,3,20}]]

FindLinearRecurrence[DeleteMissing@seq]//Head

FindSequenceFunction[DeleteMissing@seq,n-2]//Head

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

LowerMatchingNumber

Looks like A047218

seq=Table[GraphData[{"Goldberg",n},"LowerMatchingNumber"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

MatchingGeneratingPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"MatchingGeneratingPolynomial"],{n,k0=3,20}]/.f_Function:>f[x])//Column

FindLinearRecurrence[DeleteMissing@Take[poly,5]]//Head//Timing

<<MathWorld`Polynomial`

FindPolynomialRecurrence[DeleteMissing@poly,4]

FindPolynomialRecurrence[DeleteMissing@poly,6]

MatchingNumber

seq=Table[GraphData[{"Goldberg",n},"MatchingNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]

MatchingPolynomial

Take[poly=Factor@Table[GraphData[{"Goldberg",n},"MatchingPolynomial"][x],{n,k0=1,20}],6]//Column

coef=Factor/@FindLinearRecurrence[poly]

FullSimplify[poly2-poly]

MaximalCliqueCount

seq=Table[GraphData[{"Goldberg",n},"MaximalCliqueCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

gf=(x^3)FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]

MaximalCliquePolynomial

(poly=Table[GraphData[{"Goldberg",n},"MaximalCliquePolynomial"],{n,3,20}]/.f_Function:>f[x])//Column

MaximalIndependencePolynomial

(poly=Table[GraphData[{"Goldberg",n},"MaximalIndependencePolynomial"],{n,3,20}]/.f_Function:>f[x])//Column

MaximalIndependentEdgeSetCount

seq=Table[GraphData[{"Goldberg",n},"MaximalIndependentEdgeSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

MaximalIndependentVertexSetCount

seq=Table[GraphData[{"Goldberg",n},"MaximalIndependentVertexSetCount"],{n,3,20}]

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

MaximalIrredundancePolynomial

poly=Table[GraphData[{"Goldberg",n},"MaximalIrredundancePolynomial"],{n,3,20}]/.f_Function:>f[x]

MaximalIrredundantSetCount

seq=Table[GraphData[{"Goldberg",n},"MaximalIrredundantSetCount"],{n,3,20}]

MaximalMatchingGeneratingPolynomial

poly=Table[GraphData[{"Goldberg",n},"MaximalMatchingGeneratingPolynomial"],{n,3,20}]/.f_Function:>f[x]

MaximumCliqueCount

seq=Table[GraphData[{"Goldberg",n},"MaximumCliqueCount"],{n,3,20}]

gf=(x^3)FindGeneratingFunction[seq,x]

SeriesCoefficient[gf,{x,0,n}]

MaximumIndependentEdgeSetCount

Computed for n<=12; inferred beyond

seq=Table[GraphData[{"Goldberg",n},"MaximumIndependentEdgeSetCount"],{n,3,20}]

FindLinearRecurrence[DeleteMissing@seq]//Head

FindSequenceFunction[DeleteMissing@seq,n-2]//FullSimplify

Table[(1/2)((((1-(Sqrt[6])))^n)+(((1+(Sqrt[6])))^n)),{n,10}]//Expand

gf=(x^3)FindGeneratingFunction[DeleteMissing@seq,x]//FullSimplify//Factor

SeriesCoefficient[gf,{x,0,n}]

seq=Table[1+(((1-(Sqrt[6])))^n)+(((1+(Sqrt[6])))^n)+(2^n)LucasL[n,1/2],{n,30}]//Expand

FindLinearRecurrence[seq]

RSolve[{a[n]==4a[n-1]+4a[n-2]-20a[n-3]-7a[n-4]+20a[n-5],a[1]==4,a[2]==24,a[3]==52,a[4]==196,a[5]==584},a[n],n]

First term

A002533

Table[(1/2)((((1-(Sqrt[6])))^n)+(((1+(Sqrt[6])))^n)),{n,10}]//Expand

lucas_number2(n,2,-5)/2

RSolve[{a[n]==2a[n-1]+5a[n-2],a[1]==1,a[2]==7},a[n],n]

FindGeneratingFunction[Table[(1/2)((((1-(Sqrt[6])))^n)+(((1+(Sqrt[6])))^n)),{n,20}],t]//Factor

Lucas:

Table[((((x-(Sqrt[(x^2)+4])))^n)+(((x+(Sqrt[(x^2)+4])))^n)),{n,3}]//Expand

Solve[Thread[%=={1,7,19}],x]//FullSimplify

Table[(2^n)((((x-(Sqrt[(x^2)+4])))^n)+(((x+(Sqrt[(x^2)+4])))^n)),{n,3}]//Expand

Solve[Thread[%=={1,7,19}],x]//FullSimplify

Fibonacci:

Table[((((((x+(Sqrt[(x^2)+4])))^n)-(((x-(Sqrt[(x^2)+4])))^n)))/((2^n)(Sqrt[(x^2)+4]))),{n,3}]//Expand

Solve[Thread[%=={1,7,19}],x]//FullSimplify

Table[(2^n)((((((x+(Sqrt[(x^2)+4])))^n)-(((x-(Sqrt[(x^2)+4])))^n)))/((2^n)(Sqrt[(x^2)+4]))),{n,3}]//Expand

Solve[Thread[%=={1,7,19}],x]//FullSimplify

Second term

A072265

Table[((((1/2) (1-(Sqrt[17]))))^n)+((((1/2) (1+(Sqrt[17]))))^n),{n,10}]//Expand

Table[(2^n)((2^(-n))((((x-(Sqrt[(x^2)+4])))^n)+(((x+(Sqrt[(x^2)+4])))^n))),{n,3}]//Expand

Solve[Thread[%=={1,9,13}],x]//FullSimplify

FindGeneratingFunction[Table[((((1/2) (1-(Sqrt[17]))))^n)+((((1/2) (1+(Sqrt[17]))))^n),{n,20}],t]//Factor

Table[(2^n)LucasL[n,1/2],{n,10}]

MaximumIndependentVertexSetCount

seq=Table[GraphData[{"Goldberg",n},"MaximumIndependentVertexSetCount"],{n,3,20}]

seq[[3;;All;;2]]

seq[[4;;All;;2]]

MaximumIrredundantSetCount

seq=Table[GraphData[{"Goldberg",n},"MaximumIrredundantSetCount"],{n,3,20}]

MaximumLeafNumber

seq=Table[GraphData[{"Goldberg",n},"MaximumLeafNumber"],{n,3,20}]

MaximumVertexDegree

seq=Table[GraphData[{"Goldberg",n},"MaximumVertexDegree"],{n,3,20}]

MeanClusteringCoefficient

seq=Table[GraphData[{"Goldberg",n},"MeanClusteringCoefficient"],{n,3,20}]

MeanDistance

seq=Table[GraphData[{"Goldberg",n},"MeanDistance"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

Median

seq=Table[GraphData[{"Goldberg",n},"Median"],{n,3,20}]//Union

MetricDimension

seq=Table[GraphData[{"Goldberg",n},"MetricDimension"],{n,3,20}]

MinimalConnectedDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"MinimalConnectedDominatingSetCount"],{n,3,20}]

MinimalConnectedDominationPolynomial

seq=Table[GraphData[{"Goldberg",n},"MinimalConnectedDominationPolynomial"],{n,3,20}]

MinimalDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"MinimalDominatingSetCount"],{n,3,20}]

MinimalDominationPolynomial

(poly=Table[GraphData[{"Goldberg",n},"MinimalDominationPolynomial"],{n,3,20}]/.f_Function:>f[x])//Column

MinimalEdgeCoverCount

seq=Table[GraphData[{"Goldberg",n},"MinimalEdgeCoverCount"],{n,3,20}]

MinimalEdgeCoverPolynomial

poly=Table[GraphData[{"Goldberg",n},"MinimalEdgeCoverPolynomial"],{n,3,20}]/.f_Function:>f[x]

MinimalTotalDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"MinimalTotalDominatingSetCount"],{n,3,20}]

MinimalTotalDominationPolynomial

poly=Table[GraphData[{"Goldberg",n},"MinimalTotalDominationPolynomial"],{n,3,20}]/.f_Function:>f[x]

MinimalVertexCoverCount

seq=Table[GraphData[{"Goldberg",n},"MinimalVertexCoverCount"],{n,3,20}]

MinimalVertexCoverPolynomial

(poly=Table[GraphData[{"Goldberg",n},"MinimalVertexCoverPolynomial"],{n,3,20}]/.f_Function:>f[x])//Column

MinimumCliqueCoveringCount

seq=Table[GraphData[{"Goldberg",n},"MinimumCliqueCoveringCount"],{n,3,20}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"MinimumConnectedDominatingSetCount"],{n,3,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

MinimumCoveringsByMaximalCliquesCount

seq=Table[GraphData[{"Goldberg",n},"MinimumCoveringsByMaximalCliquesCount"],{n,3,20}]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"Goldberg",n},"MinimumDistinguishingLabelingCount"],{n,3,20}]

FindSequenceFunction[seq,n-4]

MinimumDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"MinimumDominatingSetCount"],{n,3,20}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"Goldberg",n},"MinimumEdgeCoverCount"],{n,3,20}]

MinimumLeafNumber

seq=Table[GraphData[{"Goldberg",n},"MinimumLeafNumber"],{n,3,20}]

MinimumPathCoveringCount

seq=Table[GraphData[{"Goldberg",n},"MinimumPathCoveringCount"],{n,3,20}]

MinimumTotalDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"MinimumTotalDominatingSetCount"],{n,3,20}]

MinimumVertexCoverCount

seq=Table[GraphData[{"Goldberg",n},"MinimumVertexCoverCount"],{n,3,20}]

MinimumVertexCutCount

seq=Table[GraphData[{"Goldberg",n},"MinimumVertexCutCount"],{n,3,20}]

MinimumVertexDegree

seq=Table[GraphData[{"Goldberg",n},"MinimumVertexDegree"],{n,3,20}]

MolecularTopologicalIndex

seq=Table[GraphData[{"Goldberg",n},"MolecularTopologicalIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]

FindGeneratingFunction[seq,x]

Nonhamiltonian

Table[GraphData[{"Goldberg",n},"Nonhamiltonian"],{n,3,20}]

NoPerfectMatching

Table[GraphData[{"Goldberg",n},"NoPerfectMatching"],{n,3,20}]

OddChordlessCycleCount

A362546

seq=Table[GraphData[{"Goldberg",n},"OddChordlessCycleCount"],{n,3,20}]

Do[Print[{{"Goldberg",n},{0,OddChordlessCyclePolynomial[GraphData[{"Goldberg",n}],1]//Timing}}],{n,3,20}]

OddChordlessCyclePolynomial

(poly=Table[GraphData[{"Goldberg",n},"OddChordlessCyclePolynomial"],{n,3,20}]/.f_Function:>f[x])//Column

Outerplanar

Table[GraphData[{"Goldberg",n},"Outerplanar"],{n,3,20}]

PageRankCentralities

PathCount

seq=Table[GraphData[{"Goldberg",n},"PathCount"],{n,3,20}]

FindLinearRecurrence[DeleteMissing@seq]

FindSequenceFunction[DeleteMissing@seq,n]//FullSimplify

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

PathCoveringNumber

seq=Table[GraphData[{"Goldberg",n},"PathCoveringNumber"],{n,3,20}]

PathPolynomial

(poly=Factor[Table[GraphData[{"Goldberg",n},"PathPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

CoefficientList[Take[poly,7],x]

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

PentagonCount

seq=Table[GraphData[{"Goldberg",n},"PentagonCount"],{n,3,20}]

FindSequenceFunction[seq,n-4]

Perfect

Table[GraphData[{"Goldberg",n},"Perfect"],{n,3,20}]

PerfectMatching

Table[GraphData[{"Goldberg",n},"PerfectMatching"],{n,3,20}]

Periphery

seq=Table[GraphData[{"Goldberg",n},"Periphery"],{n,3,20}]

Planar

Table[GraphData[{"Goldberg",n},"Planar"],{n,3,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"Goldberg",n},"ProjectivePlaneCrossingNumber"],{n,3,20}]

Pseudoarboricity

seq=Table[GraphData[{"Goldberg",n},"Pseudoarboricity"],{n,3,20}]

QChromaticPolynomial

(poly=Factor[Table[GraphData[{"Goldberg",n},"QChromaticPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x]])//Column

RadialityCentralities

seq=Table[GraphData[{"Goldberg",n},"RadialityCentralities"],{n,3,20}]

RadioLabelingCount

seq=Table[GraphData[{"Goldberg",n},"RadioLabelingCount"],{n,3,20}]

RadioNumber

seq=Table[GraphData[{"Goldberg",n},"RadioNumber"],{n,3,20}]

Radius

seq=Table[GraphData[{"Goldberg",n},"Radius"],{n,3,20}]

Rank

seq=Table[GraphData[{"Goldberg",n},"Rank"],{n,3,20}]

RankPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"RankPolynomial"],{n,k0=4,20}]/.f_Function:>f[x,y])//Column

coef=Factor/@FindLinearRecurrence[poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"Goldberg",n},"RectilinearCrossingNumber"],{n,3,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

Regular

Table[GraphData[{"Goldberg",n},"Regular"],{n,3,20}]

RegularParameters

seq=Table[GraphData[{"Goldberg",n},"RegularParameters"],{n,3,20}]

ReliabilityPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"ReliabilityPolynomial"][x],{n,k0=3,20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[poly]

ResistanceMatrix

MatrixForm/@Table[GraphData[{"Goldberg",n},"ResistanceMatrix"],{n,6}]

ScrambleNumber

seq=Table[GraphData[{"Goldberg",n},"ScrambleNumber"],{n,3,20}]

ShannonCapacity

seq=Table[GraphData[{"Goldberg",n},"ShannonCapacity"],{n,3,20}]

SigmaPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"SigmaPolynomial"][x],{n,k0=1,10}])//Column

coef=Factor/@FindLinearRecurrence[poly]

coef=Factor/@FindPolynomialRecurrence[poly,6]

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]

Table[n x(3x+2)-2x^2+1,{n,10}]

FullSimplify[%-poly]

Singlecross

Table[GraphData[{"Goldberg",n},"Singlecross"],{n,3,20}]//Union

Skewness

seq=Table[GraphData[{"Goldberg",n},"Skewness"],{n,3,20}]

SpanningTreeCount

seq=Table[GraphData[{"Goldberg",n},"SpanningTreeCount"],{n,10}]

FindSequenceFunction[seq,n-4]

SpectralRadius

seq=Table[GraphData[{"Goldberg",n},"SpectralRadius"],{n,3,20}]

SquareCount

seq=Table[GraphData[{"Goldberg",n},"SquareCount"],{n,3,20}]

SquareFree

Position[Table[GraphData[{"Goldberg",n},"SquareFree"],{n,3,20}],False]//Flatten

StabilityIndex

seq=Table[GraphData[{"Goldberg",n},"StabilityIndex"],{n,3,20}]

FindSequenceFunction[seq,n-4]

gf=x FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>1]

StarArboricity

seq=Table[GraphData[{"Goldberg",n},"StarArboricity"],{n,3,20}]

StatusCentralities

seq=Table[GraphData[{"Goldberg",n},"StatusCentralities"],{n,3,20}]

Strength

seq=Table[GraphData[{"Goldberg",n},"Strength"],{n,3,20}]

StronglyPerfect

Table[GraphData[{"Goldberg",n},"StronglyPerfect"],{n,3,20}]

StronglyRegular

Table[GraphData[{"Goldberg",n},"StronglyRegular"],{n,3,20}]

Symmetric

Table[GraphData[{"Goldberg",n},"Symmetric"],{n,3,20}]

SymmetricallyDistinctVertexPairCount

seq=Table[GraphData[{"Goldberg",n},"SymmetricallyDistinctVertexPairCount"],{n,3,20}]

SymmetricallyDistinctVertexPairSignature

seq=Table[GraphData[{"Goldberg",n},"SymmetricallyDistinctVertexPairSignature"],{n,3,20}]

Thickness

seq=Table[GraphData[{"Goldberg",n},"Thickness"],{n,3,20}]

TopologicalIndex

seq=Table[GraphData[{"Goldberg",n},"TopologicalIndex"],{n,3,20}]

FindSequenceFunction[seq,n-4]//FullSimplify

ToroidalCrossingNumber

seq=Table[GraphData[{"Goldberg",n},"ToroidalCrossingNumber"],{n,3,20}]

TotalDominatingSetCount

seq=Table[GraphData[{"Goldberg",n},"TotalDominatingSetCount"],{n,3,20}]

FindSequenceFunction[seq,n-4]

TotalDominationNumber

seq=Table[GraphData[{"Goldberg",n},"TotalDominationNumber"],{n,3,20}]

TotalDominationPolynomial

poly=Table[GraphData[{"Goldberg",n},"TotalDominationNumber"],{n,3,20}]/.f_Function:>f[x]

Traceable

Table[GraphData[{"Goldberg",n},"Traceable"],{n,3,20}]

TreeDepth

seq=Table[GraphData[{"Goldberg",n},"TreeDepth"],{n,3,20}]

TreeNumber

seq=Table[GraphData[{"Goldberg",n},"TreeNumber"],{n,3,20}]

Treewidth

seq=Table[GraphData[{"Goldberg",n},"Treewidth"],{n,3,20}]

Triameter

seq=Table[GraphData[{"Goldberg",n},"Triameter"],{n,3,20}]

TriangleCount

seq=Table[GraphData[{"Goldberg",n},"TriangleCount"],{n,3,20}]

FindSequenceFunction[seq,n-4]

TriangleFree

Table[GraphData[{"Goldberg",n},"TriangleFree"],{n,3,20}]

TuttePolynomial

(Table[GraphData[{"Goldberg",n},"TuttePolynomial"],{n,3,20}]/.f_Function:>f[x,y])

Unicyclic

seq=Table[GraphData[{"Goldberg",n},"Unicyclic"],{n,3,20}]

UniquelyPancyclic

seq=Table[GraphData[{"Goldberg",n},"UniquelyPancyclic"],{n,3,20}]

UnitDistance

seq=Table[GraphData[{"Goldberg",n},"UnitDistance"],{n,3,20}]

UpperDominationNumber

seq=Table[GraphData[{"Goldberg",n},"UpperDominationNumber"],{n,3,20}]

UpperIrredundanceNumber

seq=Table[GraphData[{"Goldberg",n},"UpperIrredundanceNumber"],{n,3,20}]

VertexConnectivity

Table[GraphData[{"Goldberg",n},"VertexConnectivity"],{n,3,20}]

VertexCount

seq=Table[GraphData[{"Goldberg",n},"VertexCount"],{n,3,20}]

FindSequenceFunction[seq,n-4]

VertexCoverCount

seq=Table[GraphData[{"Goldberg",n},"VertexCoverCount"],{n,3,20}]

FindSequenceFunction[seq,n-4]

x FindGeneratingFunction[DeleteCases[seq,_Missing],x]

VertexCoverNumber

seq=Table[GraphData[{"Goldberg",n},"VertexCoverNumber"],{n,3,20}]

FindSequenceFunction[seq,n-4]

VertexCoverPolynomial

(poly=Factor@Table[GraphData[{"Goldberg",n},"VertexCoverPolynomial"][x],{n,k0=1,10}])//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[(x^(n-1)) (x+n),{n,10}]

FullSimplify[poly2-poly]

VertexDegrees

Tally/@Table[GraphData[{"Goldberg",n},"VertexDegrees"],{n,3,20}]

VertexTransitive

seq=Table[GraphData[{"Goldberg",n},"VertexTransitive"],{n,3,20}]//Union

WienerIndex

seq=Table[GraphData[{"Goldberg",n},"WienerIndex"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

WienerSumIndex

seq=Table[GraphData[{"Goldberg",n},"WienerSumIndex"],{n,3,20}]

FindSequenceFunction[seq,n-4]

GraphData

Close[file]

file=OpenWrite["~/goldberg.m"]

Do[
WriteString[file,GraphDataString[GoldbergGraph[n],
"StandardName"->{"Goldberg",n},
"Name"->ToString[n]<>"\[Hyphen]Goldberg graph",
"Information"->"GoldbergSnarks",
"NotationRules"->{"Goldberg"->n},
"Classes"->{"Goldberg"},
"Skip"->{"Arboricity","ConnectedInducedSubgraphPolynomial","EdgeChromaticNumber","MinimumEdgeColoring"},
TimeConstraint->10,
MemoryConstraint->2*^9
]],{n,11,20}]

Close[file]