Zebra Graph

Author

Eric W. Weisstein
August 5, 2024

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

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

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

Graphic

GraphicsGrid[Partition[Table[ZebraGraph[n,n,VertexSize->If[n==1,.01,{"Scaled",.03}],VertexStyle->Red,EdgeStyle->Black],{n,5}],UpTo[5]],ImageSize->500,Dividers->All]

GraphicsGrid[Table[
StyleGraphs[
First[GraphData[{"Zebra",{n,m}},"Graph",If[n==1,"Linear","Grid"]]/.{_GraphData|{}->{\[Placeholder]}}],VertexSize->If[m==n==1,.02,{"Scaled",.05}]],
{m,10},{n,m}]//Quiet,ImageSize->700,Dividers->All]

TextGrid[{#,GraphData[#,"NotationRules","Zebra"]}&/@Select[DeleteCases[GraphData["Zebra"],{"Zebra",_}],FreeQ[GraphData[#,"EmbeddingClasses"],"Grid"]&],Dividers->All]

Classes

Intersection@@GraphData["Zebra","Classes"]

GraphClassesThatAreClass["Zebra"]

Special cases

Added to GraphData in V13.1

GraphData["Zebra*"]

zebras=Sort@Flatten[Table[{m,n}->RecognizeGraph[ZebraGraph[m,n],"Cache"->"InternalOnly"],{n,10},{m,n}],1]

new=Cases[zebras,HoldPattern[i_->{}]:>i]

TextGrid[{#,ZebraGraph@@#}&/@new,Dividers->All]

connected=Select[new,ConnectedGraphQ[ZebraGraph@@#]&]

disconnected=Select[new,!ConnectedGraphQ[ZebraGraph@@#]&]

TextGrid[{#,Tally[RecognizeGraph/@ConnectedGraphComponents[ZebraGraph@@#]]}&/@disconnected,Dividers->All]

Embeddings

<<MathWorld`Graphs`

{"Zebra", {3, 3}} == {"Empty", 9}

Names

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

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

{"Zebra", {4, 4}} == "4P3+4K1"

Names

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

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

{"Zebra", {4, 9}}

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

All

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

LCF

GraphData[{"Zebra",{4,9}},"LCFSignature"]

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

UnitDistance

UnitDistanceGraphQ[GraphData[{"Zebra",{4,9}}],Debug->True]

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

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

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

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

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

GraphData[{"Zebra",{4,9}},{"RCN","CN"}]

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

3D

Graph3D[GraphData[{"Zebra",{4,9}},"Edges"]]

Matchstick Subgraph

Matchstick embedding construction

g1=RotateGraph[RotateGraph[LabelGraph@ConnectedGraphComponents[][[2]],{11,24}],Pi/2]

v=Join[Table[{i,1},{i,0,6}],Table[{i,2},{i,0,6}],{{1,0},{5,0},{1,3},{5,3}}];
g2=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,5,6,7],e[8,9,10,11,12,13,14],e[17,9,2,15],e[18,13,6,16]},VertexCoordinates->v,VertexLabels->Automatic]

Options[MyGraphUnion]

g=MyGraphUnion[IndexGraph@g1,IndexGraph@g2,Offset->1,"Scaling"->False]

EdgeLengths[g]

RecognizeGraph[g]

GraphPlot@Graph[EdgeList[]]

e[l__]:=Sequence@@Partition[{l},2,1]
v=Join[CirclePoints[Csc[Pi/6]/2,6]];
v=Join[v,{0,-2}+#&/@v];
v=Join[v,Mean[v[[#]]]&/@{{5,11},{2,8}}];
v=Join[v,v[[14]]+Through[{Cos,Sin}[# Pi/4]]&/@{-1,1},v[[13]]-Through[{Cos,Sin}[# Pi/4]]&/@{-1,1}];
g1=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,5,6,1],e[8,9,10,11,12,7,8],e[5,13,11],e[2,14,8],e[16,14,15],e[17,13,18]},VertexCoordinates->v,VertexLabels->Automatic]

g=MyGraphUnion[IndexGraph@g1,IndexGraph@g2,Offset->1,"Scaling"->False]

RecognizeGraph[g]

MinimalCrossing Construction

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Zebra",{4,9}}]]]

RecognizeGraph[g]

RectilinearCrossingCount[g]

{"Zebra", {4, 10}}

GraphData[{"Zebra",{4,10}},"StandardName"]

All

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

LCF

GraphData[{"Zebra",{4,10}},"LCFSignature"]

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

UnitDistance

UnitDistanceGraphQ[GraphData[{"Zebra",{4,10}}],Debug->True]

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

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

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

UnitDistance FindSubgraphUnitDistanceEmbedding

<<MathWorld`Graphs`

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

gs=UniqueEmbeddings[l]

Matchstick

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

MinimalCrossing

GraphData[{"Zebra",{4,10}},{"RCN","CN"}]

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

3D

Graph3D[GraphData[{"Zebra",{4,10}},"Edges"]]

Matchstick Subgraph

Matchstick embedding construction

g0=;

VertexDegree[g0]//Sort//Tally

RecognizeGraph@g0

cc=ConnectedGraphComponents[g0]

IsomorphicGraphQ@@cc

g1=IndexGraph@RotateGraph[LabelGraph@cc[[1]],{33,54}]

g=MyGraphUnion[g1,2]

RecognizeGraph@g

EdgeLengths[g]

Graph[EdgeList[g]]

GraphPlot@ConnectedGraphComponents[%231][[1]]

e[l__]:=Sequence@@Partition[{l},2,1]
v=Join[CirclePoints[Csc[Pi/6]/2,6]];
v=Join[v,{0,-2}+#&/@v];
v=Join[v,Mean[v[[#]]]&/@{{5,11},{2,8}}];
v=Join[v,v[[14]]+Through[{Cos,Sin}[# Pi/4]]&/@{0,1},v[[13]]-Through[{Cos,Sin}[# Pi/4]]&/@{0,1},{v[[5]]-{1,0},v[[8]]+{1,0}}];
g1=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,5,6,1],e[8,9,10,11,12,7,8],e[5,13,11],e[2,14,8],e[16,14,15],e[17,13,18],{5,19},{8,20}},VertexCoordinates->v,VertexLabels->Automatic]

g=MyGraphUnion[g1,g1,"Scaling"->False,Offset->1]

g=

RecognizeGraph[g1]

MinimalCrossing Construction

g=RotateGraph[MinimalCrossingGraph[GraphData[{"Zebra",{4,10}}]]]

RectilinearCrossingCount[g]

{"Zebra", {5, 5}} == "C16+C8+K1"

Names

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

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

{"Zebra", {6, 6}}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

g=GraphPlot@GraphData[{"Zebra",{6,6}},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

GraphData[{"Zebra",{6,6}},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Zebra",{6,6}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Zebra",{6,6}},"Graph","IGraph"]//StyleGraphs

Bilateral

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

Circular

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

Circular construction

GraphData[{"Zebra",{6,6}},"Hamiltonian"]

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

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

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

GraphPlot@RotateGraph[,4Pi/10]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

LocalCrossingCount@g

GraphPlot@RotateGraph[,-2Pi/12]

v={#/8,(#2-If[#2>2,1,0])/7}&@@@Join[{{0,0},{1,0},{4,0},{7,0},{8,0},{1,1},{3,1},{4,1},{5,1},{7,1},{3,2},{4,2},{5,2},{1,4},{3,4},{4,4},{5,4},{7,4},{0,5},{1,5},{7,5},{8,5}},Table[{i,6},{i,0,8}],{{3,7},{5,7},{0,8},{4,8},{8,8}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,4,5,22,31,36,35,34,23,19,1,14,20,19],e[5,18,21,22],e[2,6,7,8,9,10,4],e[7,11,15,21],e[9,13,17,20],e[7,12,9],e[{23,31}],e[27,32,35,33,27],e[25,18],{14,29},e[15,16,17]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

LocalCrossingCount@g

GraphPlot@RotateGraph[,2Pi/12]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

LocalCrossingCount@g

GraphPlot@RotateGraph[,8Pi/12]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

LocalCrossingCount@g

GraphPlot@RotateGraph[,Pi/2]

v=Join[{{0,0},{4,0},{8,0},{3,1},{5,1},{3,2},{4,2},{5,2},{3,3},{4,3},{5,3}},Table[{i,4},{i,0,8}],{{0,5},{8,5}},Table[{i,6},{i,0,8}],{{3,7},{5,7},{0,8},{4,8},{8,8}}]/8;
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,3,20,22,31,36,35,34,23,21,12,1,4,8,7,6,5,3],e[15,9,6,10,8,11,17],e[{12,20}],e[{23,31}],e[27,32,35,33,27],{21,14},{18,22},{25,19},{13,29}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

LocalCrossingCount@g

gs=UnlabelGraph/@{,,,}

GraphPlot@RotateGraph[MinimalCrossingGraph[GraphData[{"Zebra",{6,6}}],"CrossingNumber"->4],{39,19}]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Zebra",{6,6}},"LocalCrossingNumber"]

GraphData[{"Zebra",{6,6}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

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

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

Select[Table[MinimalCrossingGraph[GraphData[{"Zebra",{6,6}}],"CrossingNumber"->cn,RandomSeed->i],{i,500}],!AdjacentCrossingsQ[#,cn]&]//Union//Timing

Circulant

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

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

Complement graph

compl=GraphData[{"Zebra",{6,6}},"ComplementGraph","Name"]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

gs={,RotateGraph[,{1,8}]}

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Zebra", {7, 7}}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Configuration

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

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

Perspective

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

HoneycombToroidal construction

GraphData[{"Zebra",{7,7}},"NotationRules","HoneycombToroidal"]

GeneralizedPetersen

GraphData[{"Zebra",{7,7}},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Zebra",{7,7}},"Graph","IGraph"]//StyleGraphs

Bilateral

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

Circular

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

Circular construction

GraphData[{"Zebra",{7,7}},"Hamiltonian"]

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Zebra",{7,7}},"LocalCrossingNumber"]

GraphData[{"Zebra",{7,7}},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalLocalCrossing construction

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

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

Select[Table[MinimalCrossingGraph[GraphData[{"Zebra",{7,7}}],"CrossingNumber"->cn,RandomSeed->i],{i,500}],!AdjacentCrossingsQ[#,cn]&]//Union//Timing

Circulant

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

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

Complement graph

compl=GraphData[{"Zebra",{7,7}},"ComplementGraph","Name"]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Properties

Acyclic

Table[GraphData[{"Zebra",n},"Acyclic"],{n,20}]

AdjacencyMatrixCount

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

AlgebraicConnectivity

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

AlmostHamiltonian

Table[GraphData[{"Zebra",{n,n}},"AlmostHamiltonian"],{n,20}]

Anarboricity

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

Antipodal

Table[GraphData[{"Zebra",{n,n}},"Antipodal"],{n,20}]

Apex

Table[GraphData[{"Zebra",{n,n}},"Apex"],{n,20}]

ApexCount

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

Arboricity

Table[GraphData[{"Zebra",{n,n}},"Arboricity"],{n,20}]

ArcTransitive

Table[GraphData[{"Zebra",{n,n}},"ArcTransitive"],{n,20}]

ArcTransitivity

Table[GraphData[{"Zebra",{n,n}},"ArcTransitivity"],{n,20}]

ArticulationVertexCount

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

AutomorphismCount

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

FindSequenceFunction[seq,n]

BalabanIndex

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

FindSequenceFunction[seq,n]//Factor

Bandwidth

Table[GraphData[{"Zebra",{n,n}},"Bandwidth"],{n,20}]

Bicolorable

Table[GraphData[{"Zebra",{n,n}},"Bicolorable"],{n,20}]

Biconnected

Table[GraphData[{"Zebra",{n,n}},"Biconnected"],{n,20}]

Bicubic

Table[GraphData[{"Zebra",{n,n}},"Bicubic"],{n,20}]

Bipartite

Table[GraphData[{"Zebra",{n,n}},"Bipartite"],{n,20}]

BipartiteDimension

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

Biplanar

Table[GraphData[{"Zebra",{n,n}},"Biplanar"],{n,20}]

BlockCount

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

BridgeCount

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

Bridged

Table[GraphData[{"Zebra",{n,n}},"Bridged"],{n,20}]

BroadcastTime

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

BurningNumber

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

CharacteristicPolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"CharacteristicPolynomial"],{n,k0=1,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-x))^(-1+n)) (-1+n-x),{n,k0,20}]

FullSimplify[poly2-poly]

CheegerConstant

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

Chordal

Table[GraphData[{"Zebra",{n,n}},"Chordal"],{n,20}]

ChordCount

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

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

ChordlessCycleCount

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

ChromaticInvariant

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

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

ChromaticNumber

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

FindSequenceFunction[seq,n]

ChromaticPolynomial

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

FindSequenceFunction[seq,n]

CircuitRank

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

FindSequenceFunction[seq,n]//FullSimplify

Circumference

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

FindSequenceFunction[seq,n]

Classes

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

ClawFree

Table[GraphData[{"Zebra",{n,n}},"ClawFree"],{n,20}]

CliqueCount

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

FindSequenceFunction[seq,n]

CliqueCoveringNumber

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

FindSequenceFunction[seq,n]

CliqueNumber

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

FindSequenceFunction[seq,n]

CliquePolynomial

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

Coarseness

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

CoboundaryPolynomial

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

ComplementOddChordlessCycleCount

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

ComplementOddChordlessCyclePolynomial

Conductance

Connected

ConnectedComponentCount

ConnectedDominatingSetCount

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

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedDominationNumber

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

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedDominationPolynomial

(poly=DeleteCases[Factor@Table[GraphData[{"Zebra",{n,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,20}]

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

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

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedInducedSubgraphPolynomial

(poly=DeleteCases[Factor@Table[GraphData[{"Zebra",{n,n}},"ConnectedInducedSubgraphPolynomial"][x],{n,k0=2,20}],_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,20}]

FullSimplify[poly2-poly]

Corank

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

CriticalNonplanar

Table[GraphData[{"Zebra",{n,n}},"CriticalNonplanar"],{n,20}]

CrossingNumber

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

FindSequenceFunction[DeleteCases[Drop[seq,4],_Missing],n]

Table[Floor[n/2]Floor[(n-1)/2]Floor[(n-2)/2]Floor[(n-3)/2]/4,{n,20}]

Cubic

Table[GraphData[{"Zebra",{n,n}},"CriticalNonplanar"],{n,20}]

CycleCount

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

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

FindGeneratingFunction[seq,x]

CyclePolynomial

Take[(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"CyclePolynomial"][x],{n,k0=1,20}]),10]//Column

coef=Factor/@FindLinearRecurrence[poly]

CoefficientList[poly,x]

Sum[(\[FormalK]-1)! Binomial[n,\[FormalK]](x^\[FormalK]),{\[FormalK],3,n}]

poly2=Table[(1/2) Sum[(\[FormalK]-1)! Binomial[n,\[FormalK]](x^\[FormalK]),{\[FormalK],3,n}],{n,k0,20}]//Factor

FullSimplify[poly2-poly]

poly3=Table[-(n*x*(2-x+n*x-2*HypergeometricPFQ[{1,1,1-n},{2},-x]))/4,{n,20}]

FullSimplify[poly3-poly]

Cyclic

Table[GraphData[{"Zebra",{n,n}},"Cyclic"],{n,20}]

Degeneracy

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

DegreeCentralities

Tally/@Table[GraphData[{"Zebra",{n,n}},"DegreeCentralities"],{n,20}]

DetourIndex

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

FindSequenceFunction[seq,n]//Factor

DetourPolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"DetourPolynomial"][x],{n,k0=1,20}])//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[{"Zebra",{n,n}},"Diameter"],{n,20}]

Dimension

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

DistancePolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"DistancePolynomial"][x],{n,k0=1,20}])//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[{"Zebra",{n,n}},"DistanceRegular"],{n,20}]

DistanceTransitive

Table[GraphData[{"Zebra",{n,n}},"DistanceTransitive"],{n,20}]

DistinguishingNumber

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

DomaticNumber

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

DominatingSetCount

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

DominationNumber

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

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

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

DominationPolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"DominationPolynomial"][x],{n,k0=1,20}])//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[{"Zebra",{n,n}},"Doublecross"],{n,20}]

Eccentricities

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

EccentricityCentralities

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

EdgeBetweennessCentralities

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

EdgeChromaticNumber

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

FindSequenceFunction[Rest@seq,n-1]//FullSimplify

EdgeConnectivity

Table[GraphData[{"Zebra",{n,n}},"EdgeConnectivity"],{n,20}]

EdgeCount

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

FindSequenceFunction[seq,n]

Binomial[n,2]

EdgeCoverCount

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

EdgeCoverNumber

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

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

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

EdgeCoverPolynomial

Take[poly=Factor@Table[GraphData[{"Zebra",{n,n}},"EdgeCoverPolynomial"][x],{n,k0=1,20}],UpTo[3]]//Column

coef=Factor/@FindLinearRecurrence[poly]

Sum[(-1)^(n-\[FormalK]) Binomial[n,\[FormalK]] (x+1)^Binomial[\[FormalK],2],{\[FormalK],0,n}]

poly2=Table[Sum[(-1)^(n-\[FormalK]) Binomial[n,\[FormalK]] (x+1)^Binomial[\[FormalK],2],{\[FormalK],0,n}],{n,k0,20}]

FullSimplify[Take[poly2-poly,7]]

EdgeTransitive

Table[GraphData[{"Zebra",{n,n}},"EdgeTransitive"],{n,20}]

EigenvectorCentralities

seq=Table[GraphData[{"Zebra",{n,n}},"EigenvectorCentralities"],{n,20}]

EulerianCycleCount

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

FindSequenceFunction[seq,n]

FaceCount

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

FlowPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

FractionalArboricity

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

FractionalChromaticNumber

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

FractionalEdgeChromaticNumber

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

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

Genus

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

Geodetic

Table[GraphData[{"Zebra",{n,n}},"Geodetic"],{n,20}]

Girth

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

GlobalClusteringCoefficient

seq=Table[GraphData[{"Zebra",{n,n}},"GlobalClusteringCoefficient"],{n,20}]

Gonality

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

Graceful

Table[GraphData[{"Zebra",{n,n}},"Graceful"],{n,20}]

GracefulLabelingCount

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

HamiltonConnected

Table[GraphData[{"Zebra",{n,n}},"HamiltonConnected"],{n,20}]

HamiltonDecomposable

Table[GraphData[{"Zebra",{n,n}},"HamiltonDecomposable"],{n,20}]

HamiltonDecompositionCount

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

FindSequenceFunction[seq,n]

Hamiltonian

Table[GraphData[{"Zebra",{n,n}},"Hamiltonian"],{n,20}]

HamiltonianCycleCount

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

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

HamiltonianNumber

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

HamiltonianPathCount

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

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

HamiltonianWalkCount

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

HamiltonLaceable

Table[GraphData[{"Zebra",{n,n}},"HamiltonianWalkCount"],{n,20}]

HararyIndex

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

HexagonCount

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

FindSequenceFunction[seq,n]

HosoyaIndex

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

FindSequenceFunction[seq,n]

(x^3)FindGeneratingFunction[seq,x]

FindLinearRecurrence[seq]

HStarConnected

Table[GraphData[{"Zebra",{n,n}},"HStarConnected"],{n,20}]

Hypohamiltonian

Table[GraphData[{"Zebra",{n,n}},"Hypohamiltonian"],{n,20}]

Hypotraceable

Table[GraphData[{"Zebra",{n,n}},"Hypotraceable"],{n,20}]

Identity

Table[GraphData[{"Zebra",{n,n}},"Identity"],{n,20}]

IdiosyncraticPolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"IdiosyncraticPolynomial"][x,y],{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+1)^(n-1) (x+1-n),{n,k0,10}]

FullSimplify[poly2/poly]

IndependenceNumber

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

IndependencePolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"IndependencePolynomial"],{n,k0=1,20}]/.f_Funtion:>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[n x+1,{n,l0=10}]

FullSimplify[poly2-poly]

IndependenceRatio

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

FindSequenceFunction[seq,n]

IndependentEdgeSetCount

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

Table[(I/Sqrt[2])^n HermiteH[n,-I/Sqrt[2]],{n,20}]

IndependentVertexSetCount

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

FindSequenceFunction[seq,n]

IntersectionNumber

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

IrredundanceNumber

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

IrredundancePolynomial

poly=Table[GraphData[{"Zebra",{n,n}},"IrredundanceNumber"],{n,20}]/.f_Function:>f[x]

IrredundantSetCount

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

IsolatedPointCount

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

KatzCentralities

seq=Table[GraphData[{"Zebra",{n,n}},"KatzCentralities"],{n,20}]

KirchhoffIndex

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

KirchhoffSumIndex

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

LaplacianPolynomial

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

LeafCount

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

Likelihood

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

LinearArboricity

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

LocalClusteringCoefficients

seq=Table[GraphData[{"Zebra",{n,n}},"LocalClusteringCoefficients"],{n,20}]

LongestCycleCount

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

LongestPathCount

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

LongestPathLength

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

LovaszNumber

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

LowerIndependenceNumber

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

LowerMatchingNumber

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

MatchingGeneratingPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

FullSimplify[poly2-poly]

MatchingNumber

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

Table[Floor[n/2],{n,20}]

MatchingPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

FullSimplify[poly2-poly]

MaximalCliqueCount

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

MaximalCliquePolynomial

poly=Table[GraphData[{"Zebra",{n,n}},"MaximalCliqueCount"],{n,20}]/.f_Function:>f[x]

MaximalIndependencePolynomial

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

MaximalIndependentEdgeSetCount

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

FindSequenceFunction[seq,n]

MaximalIndependentVertexSetCount

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

MaximalIrredundancePolynomial

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

MaximalIrredundantSetCount

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

MaximalMatchingGeneratingPolynomial

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

MaximumCliqueCount

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

MaximumIndependentEdgeSetCount

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

FindSequenceFunction[seq,n]

MaximumIndependentVertexSetCount

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

MaximumIrredundantSetCount

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

MaximumLeafNumber

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

MaximumVertexDegree

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

MeanClusteringCoefficient

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

MeanDistance

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

FindSequenceFunction[seq,n]

Median

seq=Table[GraphData[{"Zebra",{n,n}},"Median"],{n,20}]

MetricDimension

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

MinimalConnectedDominatingSetCount

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

MinimalConnectedDominationPolynomial

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

MinimalDominatingSetCount

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

MinimalDominatingSetSignature

seq=Table[GraphData[{"Zebra",{n,n}},"MinimalDominatingSetSignature"],{n,20}]

MinimalDominationPolynomial

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

MinimalEdgeCoverCount

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

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

FindLinearRecurrence[seq]

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

MinimalEdgeCoverPolynomial

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

MinimalTotalDominatingSetCount

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

MinimalTotalDominationPolynomial

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

MinimalVertexCoverCount

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

MinimalVertexCoverPolynomial

poly=Table[GraphData[{"Zebra",{n,n}},"MinimalVertexCoverPolynomial"],{n,20}]/.f_Function:>f[x]

MinimumCliqueCoveringCount

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

MinimumConnectedDominatingSetCount

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

FindSequenceFunction[DeleteCases[seq,_Missing],n]

MinimumCoveringsByMaximalCliquesCount

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

MinimumDistinguishingLabelingCount

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

FindSequenceFunction[seq,n]

MinimumDominatingSetCount

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

MinimumEdgeCoverCount

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

MinimumLeafNumber

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

MinimumPathCoveringCount

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

MinimumTotalDominatingSetCount

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

MinimumVertexCoverCount

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

MinimumVertexCutCount

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

MinimumVertexDegree

seq=Table[GraphData[{"Zebra",{n,n}},"MinimumVertexDegree"],{n,20}]

MolecularTopologicalIndex

seq=Table[GraphData[{"Zebra",{n,n}},"MolecularTopologicalIndex"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

Nonhamiltonian

Table[GraphData[{"Zebra",{n,n}},"Nonhamiltonian"],{n,20}]

NoPerfectMatching

Table[GraphData[{"Zebra",{n,n}},"NoPerfectMatching"],{n,20}]

OddChordlessCycleCount

seq=Table[GraphData[{"Zebra",{n,n}},"OddChordlessCycleCount"],{n,20}]

OddChordlessCyclePolynomial

poly=Table[GraphData[{"Zebra",{n,n}},"OddChordlessCyclePolynomial"],{n,20}]/.f_Function:>f[x]

Outerplanar

Table[GraphData[{"Zebra",{n,n}},"Outerplanar"],{n,20}]

PageRankCentralities

PathCount

seq=Table[GraphData[{"Zebra",{n,n}},"PathCount"],{n,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[{"Zebra",{n,n}},"PathCoveringNumber"],{n,20}]

PathPolynomial

(poly=Factor[Table[GraphData[{"Zebra",{n,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[{"Zebra",{n,n}},"PentagonCount"],{n,20}]

FindSequenceFunction[seq,n]

Perfect

Table[GraphData[{"Zebra",{n,n}},"Perfect"],{n,20}]

PerfectMatching

Table[GraphData[{"Zebra",{n,n}},"PerfectMatching"],{n,20}]

Periphery

seq=Table[GraphData[{"Zebra",{n,n}},"Periphery"],{n,20}]

Planar

Table[GraphData[{"Zebra",{n,n}},"Planar"],{n,20}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"Zebra",{n,n}},"ProjectivePlaneCrossingNumber"],{n,20}]

Pseudoarboricity

seq=Table[GraphData[{"Zebra",{n,n}},"Pseudoarboricity"],{n,20}]

QChromaticPolynomial

(poly=Factor[Table[GraphData[{"Zebra",{n,n}},"QChromaticPolynomial"],{n,k0=1,kmax=20}]/.f_Function:>f[x]])//Column

RadialityCentralities

seq=Table[GraphData[{"Zebra",{n,n}},"RadialityCentralities"],{n,20}]

RadioLabelingCount

seq=Table[GraphData[{"Zebra",{n,n}},"RadioLabelingCount"],{n,20}]

RadioNumber

seq=Table[GraphData[{"Zebra",{n,n}},"RadioNumber"],{n,20}]

Radius

seq=Table[GraphData[{"Zebra",{n,n}},"Radius"],{n,20}]

Rank

seq=Table[GraphData[{"Zebra",{n,n}},"Rank"],{n,20}]

RankPolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,n}},"RankPolynomial"],{n,k0=4,20}]/.f_Function:>f[x,y])//Column

coef=Factor/@FindLinearRecurrence[poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"Zebra",{n,n}},"RectilinearCrossingNumber"],{n,20}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

Regular

Table[GraphData[{"Zebra",{n,n}},"Regular"],{n,20}]

RegularParameters

seq=Table[GraphData[{"Zebra",{n,n}},"RegularParameters"],{n,20}]

ReliabilityPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ResistanceMatrix

MatrixForm/@Table[GraphData[{"Zebra",{n,n}},"ResistanceMatrix"],{n,6}]

ScrambleNumber

seq=Table[GraphData[{"Zebra",{n,n}},"ScrambleNumber"],{n,20}]

ShannonCapacity

seq=Table[GraphData[{"Zebra",{n,n}},"ShannonCapacity"],{n,20}]

SigmaPolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,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[{"Zebra",{n,n}},"Singlecross"],{n,20}]

Skewness

seq=Table[GraphData[{"Zebra",{n,n}},"Skewness"],{n,20}]

SpanningTreeCount

seq=Table[GraphData[{"Zebra",{n,n}},"SpanningTreeCount"],{n,10}]

FindSequenceFunction[seq,n]

SpectralRadius

seq=Table[GraphData[{"Zebra",{n,n}},"SpectralRadius"],{n,20}]

SquareCount

seq=Table[GraphData[{"Zebra",{n,n}},"SquareCount"],{n,20}]

FindSequenceFunction[seq,n]

SquareFree

Table[GraphData[{"Zebra",{n,n}},"SquareFree"],{n,20}]

StabilityIndex

seq=Table[GraphData[{"Zebra",{n,n}},"StabilityIndex"],{n,20}]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>1]

StarArboricity

seq=Table[GraphData[{"Zebra",{n,n}},"StarArboricity"],{n,20}]

StatusCentralities

seq=Table[GraphData[{"Zebra",{n,n}},"StatusCentralities"],{n,20}]

Strength

seq=Table[GraphData[{"Zebra",{n,n}},"Strength"],{n,20}]

StronglyPerfect

Table[GraphData[{"Zebra",{n,n}},"StronglyPerfect"],{n,20}]

StronglyRegular

Table[GraphData[{"Zebra",{n,n}},"StronglyRegular"],{n,20}]

Symmetric

Table[GraphData[{"Zebra",{n,n}},"Symmetric"],{n,20}]

SymmetricallyDistinctVertexPairCount

seq=Table[GraphData[{"Zebra",{n,n}},"SymmetricallyDistinctVertexPairCount"],{n,20}]

SymmetricallyDistinctVertexPairSignature

seq=Table[GraphData[{"Zebra",{n,n}},"SymmetricallyDistinctVertexPairSignature"],{n,20}]

Thickness

seq=Table[GraphData[{"Zebra",{n,n}},"Thickness"],{n,20}]

TopologicalIndex

seq=Table[GraphData[{"Zebra",{n,n}},"TopologicalIndex"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

ToroidalCrossingNumber

seq=Table[GraphData[{"Zebra",{n,n}},"ToroidalCrossingNumber"],{n,20}]

TotalDominatingSetCount

seq=Table[GraphData[{"Zebra",{n,n}},"TotalDominatingSetCount"],{n,20}]

FindSequenceFunction[seq,n]

TotalDominationNumber

seq=Table[GraphData[{"Zebra",{n,n}},"TotalDominationNumber"],{n,20}]

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

TotalDominationPolynomial

poly=Table[GraphData[{"Zebra",{n,n}},"TotalDominationNumber"],{n,20}]/.f_Function:>f[x]

Traceable

traceable=Table[GraphData[{"Zebra",{n,n}},"Traceable"],{n,20}]

Position[traceable,True]//Flatten

Position[traceable,_Missing]//Flatten

TreeDepth

seq=Table[GraphData[{"Zebra",{n,n}},"TreeDepth"],{n,20}]

TreeNumber

seq=Table[GraphData[{"Zebra",{n,n}},"TreeNumber"],{n,20}]

Treewidth

seq=Table[GraphData[{"Zebra",{n,n}},"Treewidth"],{n,20}]

Triameter

seq=Table[GraphData[{"Zebra",{n,n}},"Triameter"],{n,20}]

TriangleCount

seq=Table[GraphData[{"Zebra",{n,n}},"TriangleCount"],{n,20}]

FindSequenceFunction[seq,n]

TriangleFree

Table[GraphData[{"Zebra",{n,n}},"TriangleFree"],{n,20}]

TuttePolynomial

(Table[GraphData[{"Zebra",{n,n}},"TuttePolynomial"],{n,20}]/.f_Function:>f[x,y])

Unicyclic

seq=Table[GraphData[{"Zebra",{n,n}},"Unicyclic"],{n,20}]

UniquelyPancyclic

seq=Table[GraphData[{"Zebra",{n,n}},"UniquelyPancyclic"],{n,20}]

UnitDistance

seq=Table[GraphData[{"Zebra",{n,n}},"UnitDistance"],{n,20}]

UpperDominationNumber

seq=Table[GraphData[{"Zebra",{n,n}},"UpperDominationNumber"],{n,20}]

UpperIrredundanceNumber

seq=Table[GraphData[{"Zebra",{n,n}},"UpperIrredundanceNumber"],{n,20}]

VertexConnectivity

Table[GraphData[{"Zebra",{n,n}},"VertexConnectivity"],{n,20}]

VertexCount

seq=Table[GraphData[{"Zebra",{n,n}},"VertexCount"],{n,20}]

FindSequenceFunction[seq,n]

VertexCoverCount

seq=Table[GraphData[{"Zebra",{n,n}},"VertexCoverCount"],{n,20}]

FindSequenceFunction[seq,n]

x FindGeneratingFunction[DeleteCases[seq,_Missing],x]

VertexCoverNumber

seq=Table[GraphData[{"Zebra",{n,n}},"VertexCoverNumber"],{n,20}]

FindSequenceFunction[seq,n]

VertexCoverPolynomial

(poly=Factor@Table[GraphData[{"Zebra",{n,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[{"Zebra",{n,n}},"VertexDegrees"],{n,20}]

VertexTransitive

seq=Table[GraphData[{"Zebra",{n,n}},"VertexTransitive"],{n,20}]

And@@seq

WienerIndex

seq=Table[GraphData[{"Zebra",{n,n}},"WienerIndex"],{n,20}]

FindSequenceFunction[seq,n]

WienerSumIndex

seq=Table[GraphData[{"Zebra",{n,n}},"WienerSumIndex"],{n,20}]

FindSequenceFunction[seq,n]

Connected

connected=Select[Sort[Flatten[Table[{m,n},{n,10},{m,n}],1]],ConnectedGraphQ[ZebraGraph@@#]&]

n×n

Cases[connected,{x_,x_}:>x]

Traceable

n×n

traceable=Table[GraphData[{"Zebra",{n,n}},"Traceable"],{n,20}]

Position[traceable,True]//Flatten

Position[traceable,_Missing]//Flatten

Do[Print[{{"Zebra",{n,n}},FindHamiltonianPath[ZebraGraph[n,n]]//Timing}],{n,20}]

Hamiltonian

n×n

hamiltonian=Table[GraphData[{"Zebra",{n,n}},"Hamiltonian"],{n,20}]

Position[hamiltonian,True]//Flatten

Position[hamiltonian,_Missing]//Flatten

Do[Print[{{"Zebra",{n,n}},FindHamiltonianCycle[ZebraGraph[n,n]][[All,All,1]]//Timing}],{n,20}]

Counts

FindHamiltonianCycle[ZebraGraph[10,10],All]//Length//Timing

Jelliss

https://web.archive.org/web/20081008100704/http://www.ktn.freeuk.com/9e.htm#(2)

side 6, 7 or 8

THEOREM: The zebra cannot tour any board of side 6, 7 or 8. Proof: (a) No closed tours are possible since the path of the zebra through a2 and b1 is determinate and passes also through d4, but its paths through y1, y2, z1, z2 (where y denotes the penultimate and z the last file) are also determinate and at least one of these on a 6, 7 or 8 file board also uses d4, so we would have three moves impinging on d4, which is impossible in a tour. (b) In an open tour we have end cells, so we could avoid such a triple point by deleting one of the three moves and taking the cell at its other end as an end point. However, we only have two end-points, and we always have either more than two triple points or two points where at least four moves converge, or one point where at least five moves converge, so two deletions are insufficient. (In the general theory these multiple points are termed 'snags'.)

5×n

Thus, in particular, no zebra tour is possible on the normal chessboard. We now consider longer 5×n boards. The 5×6, 5×7, 5×8 are eliminated by the above theorem. Since each zebra move is from one colour to another no closed tours are possible on odd×odd boards, and an open tour, if possible, must start and end on cells the same colour as the corner cells (which we take to be white). On the 5×9 board the moves through the black cells b3, h3 form a 4-move short circuit, so no open tour is possible. On the 5×10 board the moves through b3, h3, c3, i3 form two 4-move circuits, so no closed tour is possible; and an open tour with one end in each circuit is impossible, since the moves through j2, j4, i1, i5 meet at f3, preventing moves c1-f3 or c5-f3, so that the moves through a2, a3, a4, b2, b4, c1, c5 form a 16-move circuit. On the 5×11 board consideration of the moves forced at the black squares a2, b1, a4, b5 and k2, j1, k4, j5 fixes the path through d2, d4, h2, h4 also; but now the moves through f1, f5 must go to c3, i3, forming a 4-move short circuit. On the 5×12 .... On the 5×13 board the moves through the black squares a2, b1, a4, b5 and m2, l1, m4, l5 fix the moves through d2, d4, j2, j4; but now the moves through g2, g4 must go to e1, e5, i1, i5, where they join with the moves from b3, l3 to form an 8-move short circuit. On the 5×14... On the 5×15...

The smallest rectangular board on which a zebra tour is possible is the surprisingly large 80-cell 5×16 board! The following tour was published in the Journal of Recreational Mathematics (1995).

8×8

As proved above, no zebra tour, open or closed, is possible on the 8×8 board. The longest zebra paths achieved are 54 moves (55 cells) open and 52 closed, and symmetric (Jelliss Chessics).

10×10

A closed 10×10 zebra tour was found by A. H. Frost as long ago as 1886 (in M.Frolow, Les Carrés Magiques, Paris 1886, Plate VII). This subject was rediscovered by Kraitchik (1927 pp.70-73) who gave two examples, one open, one closed, and full details of how they were constructed by Euler's method.

H. H. Cross gave an open tour in Fairy Chess Review February 1941 (problem 4709) - not shown here, which led T. H. Willcocks to compose a closed tour about the same time but which was not published until 1978 in Chessics, where it resulted in quatersymmetric examples by W. H. Cozens and myself. Finally, Tom Marlow (March 1998) applied the computer program he had used to count 10×10 knight tours with rotative quaternary symmetry to the zebra problem, with minor adaptations, and found there were only 6 geometrically distinct zebra tours of this type in all; these results were published in The Games and Puzzles Journal [vol.2 nr.16 1999 p.290]. All these tours are shown above.

GraphData

GraphDataString

file=OpenWrite["~/zebra.m"]

"2P2+5K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,2}],
Table[{i,0},{i,0,1,1/4}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"2P2+5K1",
"AlternateStandardNames"->SortBy[
Complement[
StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"2P2","2K2"},{"5K1"}],1],1],
{"2P2+5K1"}],
First[Flatten[{#}]]&],
"Name"->"two 2\[Hyphen]paths and 5 singletons",
"Notation"->Row[{2,Subscript["P",2],"⋃",5,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"2P2+6K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,2}],
Table[{i,0},{i,0,1,1/5}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"2P2+6K1",
"AlternateStandardNames"->SortBy[
Complement[
StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"2P2","2K2"},{"6K1"}],1],1],
{"2P2+6K1"}],
First[Flatten[{#}]]&],
"Name"->"two 2\[Hyphen]paths and 6 singletons",
"Notation"->Row[{2,Subscript["P",2],"⋃",6,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"2P2+7K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,2}],
Table[{i,0},{i,0,1,1/6}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"2P2+7K1",
"AlternateStandardNames"->SortBy[
Complement[
StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"2P2","2K2"},{"7K1"}],1],1],
{"2P2+7K1"}],
First[Flatten[{#}]]&],
"Name"->"two 2\[Hyphen]paths and 7 singletons",
"Notation"->Row[{2,Subscript["P",2],"⋃",7,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"2P3+4P2+7K1" == {"Zebra", {3, 7}}

({{{3,7}, {{{"Path",3},2},{{"Path",2},4},{"SingletonGraph",7}}}})

v=Join[
Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,5,6}],
Sequence@@Table[{{0,(i/5)},{2,(i/5)}},{i,4}],
Table[{2i,0},{i,0,1,1/6}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{4,5,6},{1,2,3},{13,14},{11,12},{9,10},{7,8}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"2P3+4P2+7K1",
"AlternateStandardNames"->SortBy[Complement[
Append[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"2P3"},{"4P2","4K2"},{"7K1"}],2],1],{"Zebra",{3,7}}],
{"2P3+4P2+7K1"}],
First[Flatten[{#}]]&],
"Name"->"two 3\[Hyphen]paths, four 2\[Hyphen]paths, and seven singletons",
"Notation"->Row[{2,Subscript["P",3],"⋃",4,Subscript["P",2],"⋃",7,Subscript["K",1]}],
"AlternateNames"->{"(3,7)\[Hyphen]zebra graph"},
"NotationRules"->{"Zebra"->{3,7}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

"2P5+2P4+2K1" == {"Zebra", {4, 5}}

({{{4,5}, {{{"Path",5},2},{{"Path",4},2},{"SingletonGraph",2}}}})

v=Join[
Sequence@@Table[{j,(i/5)},{i,3,4},{j,0,1,1/4}],
Sequence@@Table[{j,(i/5)},{i,2},{j,0,1,1/3}],
Table[{i,0},{i,0,1}]]

g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@Join[Partition[2 5+Range[2 4],4],Partition[Range[2 5],5]],1]],VertexCoordinates->v,VertexLabels->Automatic]

Tally[RecognizeGraph/@ConnectedGraphComponents[g]]

WriteString[file,GraphDataString[g,
"StandardName"->"2P5+2P4+2K1",
"AlternateStandardNames"->SortBy[Complement[
Append[StringRiffle[#,"+"]&/@StringRiffle[#,"+"]&/@Permutations[{"2P5","2P4","2K1"}],{"Zebra",{4,5}}],
{"2P5+2P4+2K1"}],
First[Flatten[{#}]]&],
"Name"->"two 3\[Hyphen]paths, four 2\[Hyphen]paths, and seven singletons",
"Notation"->Row[{2,Subscript["P",3],"⋃",4,Subscript["P",2],"⋃",7,Subscript["K",1]}],
"AlternateNames"->{"(4,5)\[Hyphen]zebra graph"},
"NotationRules"->{"Zebra"->{4,5}},
"Classes"->{"Matchstick","UnitDistance","Zebra"},
TimeConstraint->10,
Debug->True
]]

"2E"

g=MyGraphUnion[GraphData["EGraph"],2,GraphLayout->Row,"Scaling"->False]

WriteString[file,GraphDataString[g,
"StandardName"->"2E",
"Name"->"two E graphs",
"Notation"->Row[{2,"E"}],
TimeConstraint->10,
Debug->True
]]

"3E"

g=MyGraphUnion[GraphData["EGraph"],3,GraphLayout->Row,"Scaling"->False]

WriteString[file,GraphDataString[g,
"StandardName"->"3E",
"Name"->"three E graphs",
"Notation"->Row[{3,"E"}],
TimeConstraint->10,
Debug->True
]]

"4E" == {"Zebra", {4, 6}}

({{{4,6}, {{"EGraph",4}}}})

g=MyGraphUnion[GraphData["EGraph"],4,GraphLayout->Row,"Scaling"->False]

WriteString[file,GraphDataString[g,
"StandardName"->"4E",
"AlternateStandardNames"->SortBy[{"4E",{"Zebra",{4,6}}},First[Flatten[{#}]]&],
"Name"->"four E graphs",
"Notation"->Row[{4,"E"}],
"AlternateNames"->{"(4,6)\[Hyphen]zebra graph"},
"NotationRules"->{"Zebra"->{4,6}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

"4P2+7K1" == {"Zebra", {3, 5}}

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,4}],
Table[{i,0},{i,0,1,1/6}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4},{5,6},{7,8}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"4P2+7K1",
"AlternateStandardNames"->SortBy[Append[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"4P2","4K2"},{"6K1"}],1],1],{"4P2+7K1"}]],{"Zebra",{3,5}}],First[Flatten[{#}]]&],
"AlternateNames"->{"(3,5)\[Hyphen]zebra graph"},
"Name"->"four 2\[Hyphen]paths and 7 singletons",
"Notation"->Row[{4,Subscript["P",2],"⋃",7,Subscript["K",1]}],
"NotationRules"->{"Zebra"->{3,5}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

"4P3+2P2+8K1" == {"Zebra", {3, 8}}

({{{3,8}, {{{"Path",3},4},{{"Path",2},2},{"SingletonGraph",8}}}})

v=Join[
Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,3,6}],
Sequence@@Table[{{0,(i/5)},{2,(i/5)}},{i,2}],
Table[{2i,0},{i,0,1,1/7}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2,3},{4,5,6},{7,8,9},{10,11,12},{15,16},{13,14}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"4P3+2P2+8K1",
"AlternateStandardNames"->SortBy[Append[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"4P3"},{"2P2","2K2"},{"8K1"}],2],1]],First[Flatten[{#}]]&],
"AlternateNames"->{"(3,8)\[Hyphen]zebra graph"},
"Name"->"four 3\[Hyphen]paths, two 2\[Hyphen]paths, and eight singletons",
"Notation"->Row[{4,Subscript["P",3],"⋃",2,Subscript["P",2],"⋃",8,Subscript["K",1]}],
"NotationRules"->{"Zebra"->{3,8}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

"4P3+4K1" == {"Zebra", {4, 4}}

({{{4,4}, {{{"Path",3},4},{"SingletonGraph",4}}}})

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,4}],Table[{2i,0},{i,0,1,1/3}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[12],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"4P3+4K1",
"AlternateStandardNames"->SortBy[{"4K1+4P3",{"Zebra",{4,4}}},First[Flatten[{#}]]&],
"AlternateNames"->{"(4,4)\[Hyphen]zebra graph"},
"Name"->"four 3\[Hyphen]paths and four singletons",
"Notation"->Row[{4,Subscript["P",3],"⋃",4,Subscript["K",1]}],
"NotationRules"->{"Zebra"->{4,4}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

"6P2+K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,6}],Table[{i,0},{i,0,0}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P2+K1",
"AlternateStandardNames"->SortBy[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"6P2","6K2"},{"K1"}],1],1],{"6P2+K1"}]],First[Flatten[{#}]]&],
"Name"->"six 2\[Hyphen]paths and a singleton",
"Notation"->Row[{6,Subscript["P",2],"⋃",Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"6P2+2K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,6}],Table[{i,0},{i,0,1}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P2+2K1",
"AlternateStandardNames"->SortBy[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"6P2","6K2"},{"2K1"}],1],1],{"6P2+2K1"}]],First[Flatten[{#}]]&],
"Name"->"six 2\[Hyphen]paths and 2 singletons",
"Notation"->Row[{6,Subscript["P",2],"⋃",2,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"6P2+3K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,6}],Table[{i,0},{i,0,1,1/2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P2+3K1",
"AlternateStandardNames"->SortBy[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"6P2","6K2"},{"3K1"}],1],1],{"6P2+3K1"}]],First[Flatten[{#}]]&],
"Name"->"six 2\[Hyphen]paths and 3 singletons",
"Notation"->Row[{6,Subscript["P",2],"⋃",3,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"6P2+5K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,6}],Table[{i,0},{i,0,1,1/4}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P2+5K1",
"AlternateStandardNames"->SortBy[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"6P2","6K2"},{"5K1"}],1],1],{"6P2+5K1"}]],First[Flatten[{#}]]&],
"Name"->"six 2\[Hyphen]paths and 5 singletons",
"Notation"->Row[{6,Subscript["P",2],"⋃",5,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"6P2+6K1" == {"Zebra", {3, 6}}

({{{3,6}, {{{"Path",2},6},{"SingletonGraph",6}}}})

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,6}],Table[{i,0},{i,0,1,1/5}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@Partition[Range[12],2],1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P2+6K1",
"AlternateStandardNames"->SortBy[Append[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"6P2","6K2"},{"6K1"}],1],1],{"6P2+6K1"}]],{"Zebra",{3,6}}],First[Flatten[{#}]]&],
"AlternateNames"->{"(3,6)\[Hyphen]zebra graph"},
"Name"->"six 2\[Hyphen]paths and 6 singletons",
"Notation"->Row[{6,Subscript["P",2],"⋃",6,Subscript["K",1]}],
"NotationRules"->{"Zebra"->{3,6}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

"6P2+7K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,6}],Table[{i,0},{i,0,1,1/6}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P2+7K1",
"AlternateStandardNames"->SortBy[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"6P2","6K2"},{"7K1"}],1],1],{"6P2+7K1"}]],First[Flatten[{#}]]&],
"Name"->"six 2\[Hyphen]paths and 7 singletons",
"Notation"->Row[{6,Subscript["P",2],"⋃",7,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"6P2+8K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)}},{i,6}],Table[{i,0},{i,0,1,1/7}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Flatten[Partition[#,2,1]&/@{{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}},1]],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P2+8K1",
"AlternateStandardNames"->SortBy[Complement[Sort[StringRiffle[#,"+"]&/@Flatten[Permutations/@Flatten[Outer[List,{"6P2","6K2"},{"8K1"}],1],1],{"6P2+8K1"}]],First[Flatten[{#}]]&],
"Name"->"six 2\[Hyphen]paths and 8 singletons",
"Notation"->Row[{6,Subscript["P",2],"⋃",8,Subscript["K",1]}],
TimeConstraint->10,
Debug->True
]]

"6P3+K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,0}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+K1",
"AlternateStandardNames"->{"K1+6P3"},
"Name"->"six 3\[Hyphen]paths and a singleton",
"Notation"->Row[{6,Subscript["P",3],"⋃",Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+2K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+2K1",
"AlternateStandardNames"->{"2K1+6P3"},
"Name"->"six 3\[Hyphen]paths and two singletons",
"Notation"->Row[{6,Subscript["P",3],"⋃",2,Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+3K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1,1/2}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+3K1",
"AlternateStandardNames"->{"3K1+6P3"},
"Name"->"six 3\[Hyphen]paths and three singletons",
"Notation"->Row[{6,Subscript["P",3],"⋃",3,Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+4K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1,1/3}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+4K1",
"AlternateStandardNames"->{"4K1+6P3"},
"Name"->"six 3\[Hyphen]paths and four singletons",
"Notation"->Row[{6,Subscript["P",3],"⋃",4,Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+5K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1,1/4}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+5K1",
"AlternateStandardNames"->{"5K1+6P3"},
"Name"->"six 3\[Hyphen]paths and five singletons",
"Notation"->Row[{6,Subscript["P",3],"⋃",5,Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+6K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1,1/5}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+6K1",
"AlternateStandardNames"->{"6K1+6P3"},
"Name"->"six 3\[Hyphen]paths and six singletons",
"Notation"->Row[{6,Subscript["P",3],"⋃",6,Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+7K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1,1/6}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+7K1",
"AlternateStandardNames"->{"7K1+6P3"},
"Name"->"six 3\[Hyphen]paths and seven singletons",
"Notation"->Row[{6,Subscript["P",3],"⋃",7,Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+8K1"

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1,1/7}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+8K1",
"AlternateStandardNames"->{"8K1+6P3"},
"Name"->"six 3\[Hyphen]paths and eight singletons",
"Notation"->Row[{6,Subscript["P",3],"⋃",8,Subscript["K",1]}],
"Skip"->{"MinimumDistinguishingLabelings"},
TimeConstraint->10,
Debug->True
]]

"6P3+9K1" == {"Zebra", {3, 9}}

({{{3,9}, {{{"Path",3},6},{"SingletonGraph",9}}}})

v=Join[Sequence@@Table[{{0,(i/5)},{1,(i/5)},{2,(i/5)}},{i,6}],Table[{2i,0},{i,0,1,1/8}]];
g=Graph[Range[Length[v]],UndirectedEdge@@@Sort[Sort/@Join@@(Partition[#,2,1]&/@Partition[Range[18],3])],VertexCoordinates->v,VertexLabels->Automatic]

WriteString[file,GraphDataString[g,
"StandardName"->"6P3+9K1",
"AlternateStandardNames"->SortBy[{{"9K1+6P3","Zebra",{3,9}}},First[Flatten[{#}]]&],
"AlternateNames"->{"(3,9)\[Hyphen]zebra graph"},
"Name"->"six 3\[Hyphen]paths and nine singletons",
"Skip"->{"MinimumDistinguishingLabelings"},
"Notation"->Row[{6,Subscript["P",3],"⋃",9,Subscript["K",1]}],
"NotationRules"->{"Zebra"->{3,9}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

"C16+C8+K1" == {"Zebra", {5, 5}}

({{{5,5}, {{{"Cycle",16},1},{{"Cycle",8},1},{"SingletonGraph",1}}}})

g=MyGraphUnion[Sequence@@(GraphData[#,"Graph","UnitDistance"][[1]]&/@{"C16","C8","K1"}),"Scaling"->False]

UnitDistanceGraphEmbeddingQ[g]

WriteString[file,GraphDataString[g,
"StandardName"->"C16+C8+K1",
"AlternateStandardNames"->SortBy[
Complement[
Append[Complement[Sort[StringRiffle[#,"+"]&/@Permutations[{"C16","C8","K1"}],{"C16+C8+K1"}]],{"Zebra",{5,5}}],
{"C16+C8+K1"}],
First[Flatten[{#}]]&],
"AlternateNames"->{"(5,5)\[Hyphen]zebra graph"},
"Name"->"hexadecagon, octagon, and singleton",
"Notation"->Row[{Subscript["C",16],"⋃",Subscript["C",8],"⋃",Subscript["K",1]}],
"NotationRules"->{"Zebra"->{5,5}},
"Classes"->{"Zebra"},
TimeConstraint->10,
Debug->True
]]

m×n up to 10×10

file=OpenAppend["~/zebra.m"]

WriteString[file,GraphDataString[ZebraGraph@@#,
"StandardName"->{"Zebra",#},
"Name"->"("<>StringRiffle[ToString/@#,","]<>")\[Hyphen]zebra graph",
"EmbeddingClasses"->{"Grid","IntegerCoordinates"},
"NotationRules"->{"Zebra"->#},
"Information"->"ZebraGraph",
"Classes"->{"Zebra"},
"Skip"->{"Arboricity","ConnectedInducedSubgraphPolynomial"},
TimeConstraint->10,
Debug->True
]]&/@{{4,7},{4,8},{4,9},{4,10}};

Close[file]

n×n up to 20×20

file=OpenAppend["~/zebra.m"]

WriteString[file,GraphDataString[ZebraGraph@@#,
"StandardName"->{"Zebra",#},
"Name"->"("<>StringRiffle[ToString/@#,","]<>")\[Hyphen]zebra graph",
"NotationRules"->{"Zebra"->#},
"Information"->"ZebraGraph",
"Classes"->{"Zebra"},
"Skip"->{"Arboricity","ConnectedInducedSubgraphPolynomial","DominatingSet","TotalDominatingSet"},
TimeConstraint->10,
Debug->True
]]&/@Table[{n,n},{n,20,20}]

Close[file]