Dipyramidal Graph

Author

Eric W. Weisstein
September 16, 2022

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

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

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

Figure

Graphs.m

GraphicsGrid[Partition[Table[Show[DipyramidalGraph[n]//StyleGraphs[#,VertexSize->{"Scaled",.05}]&,PlotLabel->Style[HoldForm[n]==n,FontFamily->"Times"]],{n,3,10}],4],ImageSize->400,Dividers->All]

GraphData "Graph"

GraphicsGrid[Partition[Table[Show[GraphData[{"Dipyramid",n}]//StyleGraphs[#,VertexSize->{"Scaled",.05}]&,PlotLabel->Style[HoldForm[n]==n,FontFamily->"Times"]],{n,3,10}],4],ImageSize->400,Dividers->All]

GraphData "3D"

GraphicsGrid[Partition[Table[Show[GraphData[{"Dipyramid",n},"Graph","3D"]//StyleGraphs[#,VertexSize->{"Scaled",.05}]&,PlotLabel->Style[HoldForm[n]==n,FontFamily->"Times"]],{n,3,10}],4],ImageSize->400,Dividers->All]

GraphData {"3D","UnitDistance"}

GraphicsGrid[Partition[Table[GraphData[{"Dipyramid",n},"Graph",{"3D","UnitDistance"}]/.{
{}->"",
{g_System`Graph,___}:>Show[g//StyleGraphs[#,VertexSize->{"Scaled",.05}]&,PlotLabel->Style[HoldForm[n]==n,FontFamily->"Times"]]
},{n,3,10}],4],ImageSize->400,Dividers->All]

Special cases

TextGrid[DeleteCases[Table[{n,rg=DipyramidalGraph[n]//RecognizeGraph},{n,3,20}],{_,{"Dipyramid",_}}],Dividers->All]

Embeddings

<<MathWorld`Graphs`

{"Dipyramid", 3}

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

Primary

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

Default embedding

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

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

RecognizeGraph[g]

All

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

Embedding types

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

Degenerate

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

Planar

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

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

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Dipyramid",3}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Dipyramid",3}],"OuterFace"->#]&/@faces

gs=Annotate[#,VertexLabels->None]&/@{}

Tutte embedding construction 3

GraphPlot[RotateGraph[,2Pi/3]]

v=Join[{{-1,0},{1,0},{0,1/4},{0,3/4},{0,Sqrt[3]}}];
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,5,1,3,2,4,1],e[3,4,5]},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

Circulant

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

Halin

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

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

LCF

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

GraphData[{"Dipyramid",3},"LCFSignature"]

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

UnitDistance

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

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Dipyramid",3},"Polyhedron"]}]

3D Canonical

GraphData[{"Dipyramid",3},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Dipyramid",3},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Dipyramid",3}],-1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

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]

{"Dipyramid", 5}

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

Primary

GraphData[{"Dipyramid",5}]//StyleGraphs

Graphs.m

DipyramidalGraph[5]//StyleGraphs

Default embedding

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

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

RecognizeGraph[g]

All

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

Embedding types

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

Degenerate

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

Planar

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

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

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Dipyramid",5}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Dipyramid",5}],"OuterFace"->#]&/@faces

gs=Annotate[#,VertexLabels->None]&/@{}

Tutte embedding construction

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

RecognizeGraph[g]

MinimalCrossing

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

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

MinimalCrossing construction

g=RotateGraph[MinimalCrossingGraph[GraphData[{"Dipyramid",5}],"CrossingNumber"->-1]]

RecognizeGraph[g]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

Halin

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

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

LCF

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

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

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

UnitDistance

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

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Dipyramid",5},"Polyhedron"]}]

3D Canonical

GraphData[{"Dipyramid",5},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Dipyramid",5},"Polyhedron","Canonical"],Yellow,Sphere[]}]

3D Canonical construction

Graphics3D[{FaceForm[Green,Red],poly=GraphPolyhedron[GraphData[{"Dipyramid",5}],1]}]

(can=FindCanonicalPolyhedron[poly,WorkingPrecision->50,MaxIterations->50000,PrecisionGoal->20,"ProgressInterval"->1000,"TangentFactor"->1/10,"PlanarFactor"->1/10,Debug->True])//Timing

SimplePolyhedronQ[can]

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]

{"Dipyramid", 6}

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

Primary

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

All

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

Graphs.m

g=DipyramidalGraph[6]

Default embedding

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

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

RecognizeGraph[g]

Embedding types

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

Degenerate

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

Circular

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

Planar

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

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

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Dipyramid",6}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Dipyramid",6}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circulant

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

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

Halin

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

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

LCF

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

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

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

UnitDistance

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

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Dipyramid",6},"Polyhedron"]}]

3D Canonical

GraphData[{"Dipyramid",6},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Dipyramid",6},"Polyhedron","Canonical"],Yellow,Sphere[]}]

{"Dipyramid", 8}

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

Primary

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

All

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

Default embedding

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

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

RecognizeGraph[g]

Embedding types

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

Degenerate

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

Circular

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

Planar

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

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

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Dipyramid",8}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Dipyramid",8}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circulant

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

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

Halin

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

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

LCF

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

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

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

UnitDistance

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

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

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

3D Canonical

GraphData[{"Dipyramid",8},"Graph",{"3D","Canonical"}]

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

{"Dipyramid", 12}

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

Primary

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

All

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

Default embedding

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

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

RecognizeGraph[g]

Embedding types

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

Degenerate

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

Circular

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

Planar

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

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

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Dipyramid",12}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Dipyramid",12}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circulant

GraphData[{"Dipyramid",12},"Circulant"]

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

Halin

GraphData[{"Dipyramid",12},"Halin"]

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

LCF

GraphData[{"Dipyramid",12},"LCF"]

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

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

UnitDistance

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

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

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

Matchstick

GraphData[{"Dipyramid",12},"Matchstick"]

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Dipyramid",12},"Polyhedral"]

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

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

3D Canonical

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

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

{"Dipyramid", 16}

GraphData[{"Dipyramid",16},"StandardName"]

Primary

GraphData[{"Dipyramid",16}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"Dipyramid",16},"Graph","All"]//StyleGraphs

Graphs.m

DipyramidalGraph[16]//StyleGraphs

Default embedding

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

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

RecognizeGraph[g]

Embedding types

GraphDataEmbeddings[GraphData[{"Dipyramid",16},"EdgeList"]]

Degenerate

GraphData[{"Dipyramid",16},"Graph","Degenerate"]//StyleGraphs

Circular

GraphData[{"Dipyramid",16},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"Dipyramid",16},"Planar"]

GraphData[{"Dipyramid",16},"Graph","Planar"]//StyleGraphs

Tutte embeddings

faces=ReverseSort@SymmetricallyDistinctFaces[GraphData[{"Dipyramid",16}]]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[GraphData[{"Dipyramid",16}],"OuterFace"->#]&/@faces

gs=Annotate[#,{VertexLabels->None,ImageSize->Tiny}]&/@{}

RecognizeGraph/@gs

Tutte embedding construction

GraphPlot[RotateGraph[]]

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

RecognizeGraph[g]

Circulant

GraphData[{"Dipyramid",16},"Circulant"]

GraphData[{"Dipyramid",16},"Graph","Circulant"]//StyleGraphs

Halin

GraphData[{"Dipyramid",16},"Halin"]

GraphData[{"Dipyramid",16},"Graph","Halin"]//StyleGraphs

LCF

GraphData[{"Dipyramid",16},"LCF"]

GraphData[{"Dipyramid",16},"LCFSignature"]

GraphData[{"Dipyramid",16},"Graph","LCF"]//StyleGraphs

UnitDistance

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

UnitDistanceGraphQ[GraphData[{"Dipyramid",16}],Debug->True]//Timing

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

Matchstick

GraphData[{"Dipyramid",16},"Matchstick"]

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

GraphData[{"Dipyramid",16},"Polyhedral"]

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

Graphics3D[{FaceForm[Green,Red],GraphData[{"Dipyramid",16},"Polyhedron"]}]

3D Canonical

GraphData[{"Dipyramid",16},"Graph",{"3D","Canonical"}]

Graphics3D[{Opacity[.5],Red,GraphData[{"Dipyramid",16},"Polyhedron","Canonical"],Yellow,Sphere[]}]

Construction

From Edges

From Dipyramid

?Dipyramid

Polyhedron[Dipyramid[3]]

DipyramidalGraphFromPolyhedron[n_]:=Module[{faces=Polyhedron[Dipyramid[n]][[All,1]],v,e,vlist},
v=Union@@faces;
vlist=Range[Length[v]];
e=Union@@((Sort/@Partition[#,2,1,1])&/@(faces/.Thread[v->vlist]));
System`Graph[vlist,e,VertexCoordinates->v]
]

g=DipyramidalGraphFromPolyhedron[3]

rg=RecognizeGraph[%]

ToCommonEdges[g,GraphData[rg]]

{{{0,0,-Sqrt[(2/3)]},{0,0,Sqrt[2/3]},{-(1/(2 Sqrt[3])),-(1/2),0},{-(1/(2 Sqrt[3])),1/2,0},{1/Sqrt[3],0,0}}}==={{{0,0,-(Sqrt[(2/3)])},{0,0,(Sqrt[(2/3)])},{-(1/(2 (Sqrt[3]))),-(1/2),0},{-(1/(2 (Sqrt[3]))),(1/2),0},{(1/(Sqrt[3])),0,0}}}

Planar

With[{x1=1/2,x2=0,x3=0,x4=1,y1=0,y2=(Sqrt[3])/2,y3=yy,y4=yy},
Det[{
{
Det[{{x1,y1},{x2,y2}}],
x1-x2
},
{
Det[{{x3,y3},{x4,y4}}],
x3-x4
}}
]/Det[{{x1-x2,y1-y2},{x3-x4,y3-y4}}]
]//FullSimplify

Simplify[-p+ x 2p/(n-1)]

RegionIntersection[InfiniteLine[{{1/2,0},{0,(Sqrt[3])/2}}],InfiniteLine[{{0,y2},{1,y2}}]][[1,1]]

DipyramidalGraph2[n_,opts___?OptionQ]:=Module[{y1=1/n,y2=2/n,p},
p=(1/2)-(y2/(Sqrt[3]));
System`Graph[Range[n+2],
UndirectedEdge@@@Union[
{{1,2},{2,3},{1,3},{1,4},{2,4},{1,5},{2,n+2}},
Table[{i,i+1},{i,5,n+1}],
Table[{3,i},{i,5,n+2}],
Table[{4,i},{i,5,n+2}]
],
VertexCoordinates->Join[
{{-1/2,0},{1/2,0},{0,(Sqrt[3])/2},{0,y1}},
Table[{p (((2 x)/(n-1))-1) ,y2},{x,n-2}]],
VertexLabels->"Name",
opts]
]

Table[DipyramidalGraph2[n],{n,3,12}]

RecognizeGraph/@Table[DipyramidalGraph[n],{n,3,20}]

Properties

Acyclic

Table[GraphData[{"Dipyramid",n},"Acyclic"],{n,3,20}]

AdjacencyMatrixCount

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

Table[(((n+2)!)/(4n)),{n,3,20}]

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

Anarboricity

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

Arboricity

seq=Table[GraphData[{"Dipyramid",n},"Arboricity"],{n,3,20}]

ArcTransitive

Table[GraphData[{"Dipyramid",n},"ArcTransitive"],{n,3,20}]

ArcTransitivity

Table[GraphData[{"Dipyramid",n},"ArcTransitivity"],{n,3,20}]

AutomorphismCount

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

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

BalabanIndex

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

FindSequenceFunction[seq,n-2]

Bandwidth

Computed up to n==12; inferred beyond

seq=Table[GraphData[{"Dipyramid",n},"Bandwidth"],{n,3,20}]

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

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

BridgeCount

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

BurningNumber

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

CharacteristicPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

CoefficientList[Take[poly,10],x]

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]

ChordCount

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

FindSequenceFunction[seq,n-2]//Simplify

Chordless

seq=Table[GraphData[{"Dipyramid",n},"Chordless"],{n,3,20}]

ChordlessCycleCount

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

FindSequenceFunction[Rest@seq,n-3]//Factor

Chords

(all edges)

seq=Table[GraphData[{"Dipyramid",n},"Chords"],{n,3,5}]

ChromaticInvariant

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

FindSequenceFunction[DeleteMissing@seq,n-2]

ChromaticNumber

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

FindSequenceFunction[seq,n-2]//FullSimplify

ChromaticPolynomial

Factor@(poly=Table[GraphData[{"Dipyramid",n},"ChromaticPolynomial"],{n,k0=3,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]

Subtract@@@Table[{GraphData[{"Dipyramid",n},"ChromaticPolynomial"][x],x ((((-1))^n)-(((-3+x))^n)+(((-2+x))^n)+((((-1))^n) (-3+x)+(((-3+x))^n)) x)},{n,3,13}]//Expand

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

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

Circumference

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

FindSequenceFunction[seq,n-2]

Classes

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

CliqueCount

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

FindSequenceFunction[seq,n]

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

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

CliqueCoveringNumber

A110654

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

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

Table[Ceiling[n/2],{n,3,20}]

CliquePolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"CliquePolynomial"][x],{n,k0=3,20}])//Column

CliqueNumber

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

ComplementOddChordlessCycleCount

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

ConnectedDominatingSetCount

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

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

ConnectedDominationNumber

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

ConnectedDominationPolynomial

(poly=Table[GraphData[{"Dipyramid",n},"ConnectedDominationPolynomial"],{n,k0=3,kmax=20}]/.f_Function:>f[x])//Factor//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]

Subtract@@@Table[{GraphData[{"Dipyramid",n},"ConnectedDominationPolynomial"][x],n (x^(-2+n))+n (x^(-1+n))+(x^n)+2 x (-1+(((1+x))^n))+(x^2) (-1+(((1+x))^n))},{n,3,13}]//Expand

ConnectedInducedSubgraphCount

A308580

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

FindSequenceFunction[seq,n-2]//Simplify

Table[3 2^n+n^2-n,{n,0,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{5,-9,7,-2},{6,14,30,60},{0,20}]

gf=FindGeneratingFunction[%,x]//Factor

CoefficientList[Series[((3-9 x+11 (x^2)-7 (x^3))/((((-1+x))^3) (-1+2 x))),{x,0,20}],x]

ConnectedInducedSubgraphPolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"ConnectedInducedSubgraphPolynomial"],{n,k0=3,20}]/.f_Function:>f[x])//Factor//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=(z^k0)FindGeneratingFunction[poly,z]

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

FullSimplify[%-poly]

CrossingNumber

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

CycleCount

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

FindSequenceFunction[seq,n-2]//Factor

CyclePolynomial

Factor@(poly=Table[GraphData[{"Dipyramid",n},"CyclePolynomial"],{n,k0=3,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=(z^k0)FindGeneratingFunction[poly,z]

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

Cyclic

Table[GraphData[{"Dipyramid",n},"Cyclic"],{n,3,20}]

CyclomaticNumber

seq=Table[GraphData[{"Dipyramid",n},"CyclomaticNumber"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

DetourIndex

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

FindSequenceFunction[seq,n-2]//Factor

DetourPolynomial

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

Diameter

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

FindSequenceFunction[seq,n-2]//FullSimplify

DistancePolynomial

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

DistinguishingNumber

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

DomaticNumber

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

DominationNumber

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

Table[Floor[2(n+2)/5],{n,3,20}]

%==seq

FindSequenceFunction[seq,n-2]

FindGeneratingFunction[seq,x]

Series[x^3((2+(x^3)-(x^5))/((((-1+x))^2) (1+x+(x^2)+(x^3)+(x^4)))),{x,0,10}]

SeriesCoefficient[x^3((2+(x^3)-(x^5))/((((-1+x))^2) (1+x+(x^2)+(x^3)+(x^4)))),{x,0,n}]//FullSimplify

FullSimplify[%,n>2]

Table[(2/5) (1+n+((((-1))^(2 n/5)) ((1/2) (-5+(Sqrt[5]))+(((-1))^(4/5)) (Sqrt[5]) (E^(-(6/5) I n π))+(E^(-(4/5) I n π)) Root[25+25 #1+10 ((#1)^2)+((#1)^4)&,1]+(E^((2 I n π)/5)) Root[25+25 #1+15 ((#1)^2)+5 ((#1)^3)+((#1)^4)&,3]))/(5+Root[125+50 ((#1)^2)+((#1)^4)&,2])),{n,3,20}]//FullSimplify

RootReduce[%108]

DominationPolynomial

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

CoefficientList[Take[poly,5],x]

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

Simplify[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>2]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

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

DominatingSetCount

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

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

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

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

Table[3 (2^n)-2+RootSum[-1-#1-((#1)^2)+((#1)^3)&,#^n&],{n,3,20}]

EdgeChromaticNumber

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

EdgeConnectivity

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

EdgeCount

seq=Table[GraphData[{"Dipyramid",n},"M"],{n,3,20}]

FindSequenceFunction[seq,n-2]

EdgeCoverCount

A296995

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

seq={2,34,341,2902,23092,178393,1359598,10296846,77752133,586292914,4418053928,33282217873,250685741074,1888064403826,14219675836741,107091705316446,806526755213324,6074075885446057,45744715781412614,344509590254476102,2594546978760459973};

FullSimplify[FindSequenceFunction[DeleteMissing@seq,n],n>0&&n∈Integers]

coef=FindLinearRecurrence[DeleteMissing@seq]

Length@coef

Take[seq,6]

LinearRecurrence[{11,-24,-21,33,34,8},{2,34,341,2902,23092,178393},20]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

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

CoefficientList[Series[((-2-12 x-15 (x^2)-9 (x^3)-2 (x^4))/(-1+11 x-24 (x^2)-21 (x^3)+33 (x^4)+34 (x^5)+8 (x^6))),{x,0,20}],x]

1st piece

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

Table[LucasL[n],{n,10}]

2nd piece

2*A206776

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

%/2

RSolve[{a[n]==3 a[n-1]+2 a[n-2],a[0]==2,a[1]==3},a[n],n]

3rd piece

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

Reassemble

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

EdgeCoverNumber

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

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

EdgeCoverPolynomial

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

CoefficientList[Take[poly,4],x]//Column

FindLinearRecurrence[DeleteMissing@Drop[poly,1]]//Head

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]

EulerianCycleCount

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

FaceCount

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

FindSequenceFunction[seq,n-2]

FlowPolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"FlowPolynomial"],{n,k0=3,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]

FractionalChromaticNumber

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

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

FractionalCliqueNumber

=== FractionalChromaticNumber

seq=Table[GraphData[{"Dipyramid",n},"FractionalCliqueNumber"],{n,3,20}]

FractionalEdgeChromaticNumber

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

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

Simplify[SeriesCoefficient[gf,{x,0,n}],n>3]

Girth

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

HamiltonDecompositionCount

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

Hamiltonian

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

HamiltonianCycleCount

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

FindSequenceFunction[seq,n-2]//Factor

HamiltonianNumber

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

FindSequenceFunction[seq,n-2]

HamiltonianPathCount

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

FindSequenceFunction[Rest@seq,n-3]//Factor

HamiltonianWalkCount

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

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

HararyIndex

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

FindSequenceFunction[seq,n-2]//Factor

HexagonCount

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

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

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

IdiosyncraticPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

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

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

FullSimplify[%-poly]

IndependenceNumber

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

FindSequenceFunction[seq,n-2]//FullSimplify

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

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

IndependencePolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"IndependencePolynomial"][x],{n,k0=3,20}])//Column

CoefficientList[Take[poly,4],x]

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

Simplify[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]]

soln=FullSimplify[SeriesCoefficient[gf,{z,0,n}],n>2]

CoefficientList[Table[(2^(-n)) ((((1-(Sqrt[1+4 x])))^n)+(((1+(Sqrt[1+4 x])))^n)),{n,10}]//Expand,x]//Column

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

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

Subtract@@@Table[{x(x+2)+(x^(n/2))LucasL[n,1/(Sqrt[x])],GraphData[{"Dipyramid",n},"IndependencePolynomial"][x]},{n,3,10}]//Expand

IndependenceRatio

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

FullSimplify[FindSequenceFunction[Rest@seq,n-3],n>3&&n∈Integers]

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

IndependentEdgeSetCount

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

FindSequenceFunction[seq,n-2]

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

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

IndependentVertexSetCount

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

FindSequenceFunction[seq,n-2]//FullSimplify

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

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

Table[LucasL[n]+3,{n,3,20}]

IntersectionNumber

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

IrredundancePolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"IrredundancePolynomial"],{n,k0=4,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}]

Simplify[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]

IrredundantSetCount

A297712

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

coef=FindLinearRecurrence[Rest@seq]

Length[coef]

Take[seq,1+{1,8}]

Join[{7},LinearRecurrence[{3,-2,-1,2,-2,0,2,-1},{22,29,39,60,94,151,241,400},20]]

FindSequenceFunction[DeleteMissing@seq,n-2]

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

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

CoefficientList[Series[((7+x-23 (x^2)+3 (x^3)+9 (x^4)-9 (x^5)+14 (x^6)+2 (x^7)-6 (x^8))/((((-1+x))^2) (1-x-(x^2)-(x^4)+(x^6)))),{x,0,20}],x]

Refine[SeriesCoefficient[gf,{x,0,n}],n>3]

terms=List@@res;

N[terms/.n->0]//Chop

terms[[All,1]]

Expand[1+2 (1+n)]

Table[3+2 n+RootSum[1-((#1)^2)-((#1)^4)-((#1)^5)+((#1)^6)&,((#)^n)&],{n,40}]

Table[Piecewise[{{7,n==3}},3+2 n+RootSum[1-((#1)^2)-((#1)^4)-((#1)^5)+((#1)^6)&,((#)^n)&]],{n,3,20}]

KirchhoffIndex

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

(seq=Table[KirchhoffIndex@DipyramidalGraph[n],{n,3,40}])//Timing

FindSequenceFunction[Drop[seq,3],n-5]//Head//Timing

FindLinearRecurrence[Drop[seq,3]]//Head//Timing

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

KirchhoffSumIndex

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

(seq=Table[KirchhoffSumIndex@DipyramidalGraph[n],{n,3,40}])//Timing

FindSequenceFunction[Drop[seq,3],n-5]//Head//Timing

FindLinearRecurrence[Drop[seq,3]]//Head//Timing

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

LaplacianPolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"LaplacianPolynomial"],{n,k0=3,20}]/.f_Function:>f[x])//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]

LeafCount

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

Likelihood

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

LongestCycleCount

=== HamiltonianCycleCount

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

LongestPathLength

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

LongestPathCount

=== HamiltonianPathCount

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

LovaszNumber

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

MatchingGeneratingPolynomial

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

CoefficientList[Take[poly,5],x]

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

FormattedPolynomialRecurrence[p,x,n,coef]//TraditionalForm

TeXForm[%]

LinearRecurrence[coef,poly,{2-k0,Length[coef]-k0+1}]

FullSimplify[RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n],n∈Integers&&n>0]

gf=Factor[(z^k0)FindGeneratingFunction[poly,z]]

Simplify[SeriesCoefficient[gf,{z,0,n}],n>2]

Table[(1/(((1+4 x))^(3/2)))(2^(-n)) (-n x (2+7 x) ((((1-(Sqrt[1+4 x])))^n)-(((1+(Sqrt[1+4 x])))^n))+(n^2) (x^2) (Sqrt[1+4 x]) ((((1-(Sqrt[1+4 x])))^n)+(((1+(Sqrt[1+4 x])))^n))+(((1+4 x))^(3/2)) ((((1-(Sqrt[1+4 x])))^n)+(((1+(Sqrt[1+4 x])))^n))),{n,5}]//Factor

Table[(1/(((1+4 x))^(3/2)))(2^(-n)) (-n x (2+7 x) ((((1-(Sqrt[1+4 x])))^n)-(((1+(Sqrt[1+4 x])))^n))+((((1+4 x))^(3/2))+(n^2) (x^2) (Sqrt[1+4 x]) )((((1-(Sqrt[1+4 x])))^n)+(((1+(Sqrt[1+4 x])))^n))),{n,5}]//Factor

First piece

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

CoefficientList[%,x]

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

Second piece

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

CoefficientList[%,x]

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

Reassemble

Table[(1/(((1+4 x))^(3/2)))(2^(-n))(-n x (2+7 x) ((((1-(Sqrt[1+4 x])))^n)-(((1+(Sqrt[1+4 x])))^n)))+(1/(((1+4 x))^(3/2)))(2^(-n)) ((((1+4 x))^(3/2))+(n^2) (x^2) (Sqrt[1+4 x]) )((((1-(Sqrt[1+4 x])))^n)+(((1+(Sqrt[1+4 x])))^n)),{n,5}]//Factor

Table[((-1)/((1+4 x)))(-n x (2+7 x) (x^((n-1)/2) Fibonacci[n,1/Sqrt[x]]))+(1/(((1+4 x))^(3/2))) ((((1+4 x))^(3/2))+(n^2) (x^2) (Sqrt[1+4 x]) )x^(n/2) LucasL[n,1/Sqrt[x]],{n,5}]//Factor

FullSimplify[((-1)/((1+4 x)))(-n x (2+7 x) (x^((n-1)/2) Fibonacci[n,1/Sqrt[x]]))+(1/(((1+4 x))^(3/2))) ((((1+4 x))^(3/2))+(n^2) (x^2) (Sqrt[1+4 x]) )x^(n/2) LucasL[n,1/Sqrt[x]]]

Table[(((x^(n/2)) (n (Sqrt[x]) (2+7 x) Fibonacci[n,(1/(Sqrt[x]))]+(1+x (4+(n^2) x)) LucasL[n,(1/(Sqrt[x]))]))/(1+4 x)),{n,5}]//Factor

MatchingNumber

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

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

MatchingPolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"MatchingPolynomial"],{n,k0=3,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]]

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

MaximalCliqueCount

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

FindSequenceFunction[Rest@seq,n-2]

MaximalIndependentEdgeSetCount

A297064

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

(seq=Table[Length@FindAllMaximalIndependentEdgeSets[DipyramidalGraph[n]],{n,3,35}])//Timing

coef=FindLinearRecurrence[seq]

Length[coef]

LinearRecurrence[coef,Take[seq,Length@coef],{-1,20}]//Take[#,13]&

seq=LinearRecurrence[{0,5,3,-10,-12,7,18,4,-11,-8,1,3,1},{2,4,12,14,40,56,112,178,306,482,792,1214,1924},40]

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

gf=x FindGeneratingFunction[seq,x,ValidationLength->5]

CoefficientList[Series[-((2 (1+2 x+(x^2)-6 (x^3)-6 (x^4)+7 (x^5)+12 (x^6)-(x^7)-9 (x^8)-6 (x^9)+2 (x^11)+(x^12)))/((((-1+(x^2)))^2) (((-1+(x^2)+(x^3)))^3))),{x,0,20}],x]

Refine[SeriesCoefficient[gf,{x,0,n}],n>0&&n∈Integers]

MaximalIndependentVertexSetCount

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

FindSequenceFunction[seq,n-2]//FullSimpify

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

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

MaximalIrredundantSetCount

A297711

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

seq={4,15,21,24,29,31,49,83,89,124,170,241,374,511,732,1029,1540,2287,3294,4821,7016,10332,15261,22350,32782,48041,70703,104022};

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

FindLinearRecurrence[DeleteMissing@Drop[seq,2]]//Head//Timing

FindGeneratingFunction[seq,x,ValidationLength->5]//Head//Timing

MaximumCliqueCount

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

FindSequenceFunction[Rest@seq,n-2]

MaximumIndependentEdgeSetCount

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

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

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

MaximumIndependentVertexSetCount

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

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

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

MaximumIrredundantSetCount

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

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

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

MaximumLeafNumber

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

FindSequenceFunction[DeleteMissing@Rest@seq,n-3]

MaximumVertexDegree

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

MeanDistance

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

FindSequenceFunction[seq,n-2]//Factor

MinimalDominatingSetCount

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

FindSequenceFunction[DeleteMissing@Rest@seq,n-3]

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

Refine[SeriesCoefficient[gf,{x,0,n}],n>3]

MinimalDominatingSetSignature

seq=Table[GraphData[{"Dipyramid",n},"MinimalDominatingSetSignature"],{n,3,20}]//Column

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

MinimalEdgeCoverCount

A297713

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

seq={1,6,24,74,180,464,1113,2646,6360,15222,36795,89584,219635,542320,1346881,3361998,8427172,21195416,53455740,135112332,342093443,867325032,2201286622,5591469852,14211796995,36139507614,91934054637,233934039872,595393224041,1515602413390};

seq=Rest@CoefficientList[Series[x*(1+x)*(1+x-2*x^2-14*x^3-39*x^4+63*x^5+69*x^6+55*x^7-39*x^8-85*x^9-118*x^10-102*x^11-63*x^12-27*x^13-7*x^14-x^15)/((1-x^2-x^3)^3*(1-x-x^2-x^3)^2*(1-2*x-x^2-x^3)),{x,0,50}],x]

coef=FindLinearRecurrence[seq]

Length[coef]

Take[seq,18]

LinearRecurrence[{4,1,-12,-15,24,49,6,-73,-76,5,80,72,14,-30,-34,-19,-6,-1},{1,6,24,74,180,464,1113,2646,6360,15222,36795,89584,219635,542320,1346881,3361998,8427172,21195416},30]

FindSequenceFunction[seq,n]

gf=x Factor@FindGeneratingFunction[seq,x,ValidationLength->5]

CoefficientList[Series[-(((1+x) (-1-x+2 (x^2)+14 (x^3)+39 (x^4)-63 (x^5)-69 (x^6)-55 (x^7)+39 (x^8)+85 (x^9)+118 (x^10)+102 (x^11)+63 (x^12)+27 (x^13)+7 (x^14)+(x^15)))/((((-1+(x^2)+(x^3)))^3) (((-1+x+(x^2)+(x^3)))^2) (-1+2 x+(x^2)+(x^3)))),{x,0,20}],x]

Series[gf,{x,0,20}]

res=Refine[SeriesCoefficient[gf,{x,0,n}],n>0&&n∈Integers]

MinimalTotalDominatingSetCount

A298823

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

seq={2,4,9,12,15,21,21,20,30,45,44,49,65,77,98,132,153,180,247,329,409,528,690,889,1180,1573,2037,2657,3538,4684,6169,8164,10783,14229,18877,25036,33078,43757,57996,76809,101721,134773,178450,236284,313097,414828,549383};

coef=FindLinearRecurrence[seq]

Length[coef]

Take[seq,Length[coef]]

LinearRecurrence[{2,-1,1,-1,0,0,-1,0,1,1,-1},{2,4,9,12,15,21,21,20,30,45,44},20]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x,ValidationLength->5]

CoefficientList[Series[((2+3 (x^2)-4 (x^3)-2 (x^4)-2 (x^5)-9 (x^6)-2 (x^7)+9 (x^8)+12 (x^9)-9 (x^10))/((((-1+x))^2) (1-(x^3)-(x^4)-(x^5)-(x^6)+(x^8)+(x^9)))),{x,0,20}],x]

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

Table[2 n+RootSum[-1-#1+((#1)^3)&,#^n&]+(1+(((-1))^n)) (Root[1-#1+((#1)^3)&,2] (((Root[-1+((#1)^2)+((#1)^3)&,1])^((2+n)/2))-((Root[-1+((#1)^2)+((#1)^3)&,2])^((2+n)/2)))+Root[1-#1+((#1)^3)&,3] (((Root[-1+((#1)^2)+((#1)^3)&,1])^((2+n)/2))-((Root[-1+((#1)^2)+((#1)^3)&,3])^((2+n)/2)))),{n,20}]//RootReduce

A078712

Table[(Root[1-#1+((#1)^3)&,2] (((Root[-1+((#1)^2)+((#1)^3)&,1])^((2+n)/2))-((Root[-1+((#1)^2)+((#1)^3)&,2])^((2+n)/2)))+Root[1-#1+((#1)^3)&,3] (((Root[-1+((#1)^2)+((#1)^3)&,1])^((2+n)/2))-((Root[-1+((#1)^2)+((#1)^3)&,3])^((2+n)/2)))),{n,2,30,2}]//RootReduce

Table[RootSum[-1-#+#^3&,((#)^(-n))&],{n,20}]

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

MinimumCoveringsByMaximalCliquesCount

A298648

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

seq={1,4,30,12,98,28,270,60,682,124,1638,252,3810,508,8670,1020,19418,2044,42966,4092,94162,8188,204750,16380,442314,32764,950214,65532,2031554,131068,4325310,262140,9174970,524284,19398582,1048572,40894386,2097148,85983150};

Join[{1},Table[If[Mod[n,2]==0,2,n](2^Ceiling[n/2]-2),{n,4,20}]]

Table[Piecewise[{{1,n==3},{2(2^Ceiling[n/2]-2),Mod[n,2]==0},{(2^Ceiling[n/2]-2)n,Mod[n,2]==1}}],{n,3,20}]

FindSequenceFunction[DeleteMissing@Drop[seq,1],n-3]//Head//Timing

coef=FindLinearRecurrence[DeleteMissing@Drop[seq,1]]

Length@coef

Take[seq,1+{1,8}]

Join[{1},LinearRecurrence[{0,6,0,-13,0,12,0,-4},{4,30,12,98,28,270,60,682},20]]

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

CoefficientList[Series[((1+4 x+24 (x^2)-12 (x^3)-69 (x^4)+8 (x^5)+60 (x^6)-20 (x^8))/(((1-3 (x^2)+2 (x^4)))^2)),{x,0,20}],x]

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>3&&n∈Integers]

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

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

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

Table[(2^n)-2,{n,10}]

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

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

FullSimplify[(1+(((-1))^n)) (-2+(2^(n/2)))-(-1+(((-1))^n))((2^((n+1)/2))-2)n/2,n∈Integers]

ExpandAll[(1+(((-1))^n)) (-2+(2^(n/2)))-(-1+(((-1))^n))((2^((n+1)/2))-2)n/2]

FullSimplify[%,n∈Integers]

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

Expand[2(1+(((-1))^n)) ((2^(n/2-1))-1)-(-1+(((-1))^n))((2^((n-1)/2))-1)n]

Refine[2(1+(((-1))^n)) ((2^(n/2-1))-1)+(1-(((-1))^n))((2^((n-1)/2))-1)n,Mod[n,2]==#]&/@{0,1}//FullSimplify

MinimumConnectedDominatingSetCount

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

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

MinimumDistinguishingLabelingCount

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

FindSequenceFunction[DeleteMissing@seq,n-2]

FindGeneratingFunction[DeleteCases[seq,_Missing],x]

MinimumDominatingSetCount

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

FindSequenceFunction[DeleteMissing@Drop[seq,4],n-6]//Factor

MinimumEdgeCoverCount

A298822

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

seq={1,2,21,8,85,18,217,32,441,50,781,72,1261,98,1905,128,2737,162,3781,200,5061,242,6601,288,8425,338,10557,392,13021,450,15841,512,19041,578,22645,648,26677,722,31161,800,36121,882,41581,968,47565,1058,54097,1152};

FullSimplify[FindSequenceFunction[seq,n],n∈Integers]

coef=FindLinearRecurrence[seq]

Length[coef]

Take[seq,8]

LinearRecurrence[{0,4,0,-6,0,4,0,-1},{1,2,21,8,85,18,217,32},20]

Edge cover number:

Table[Floor[(n+3)/2],{n,20}]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((1+2 x+17 (x^2)+7 (x^4)-2 (x^5)-(x^6))/(((-1+(x^2)))^4)),{x,0,20}],x]

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

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

MinimumTotalDominatingSetCount

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

FindSequenceFunction[DeleteMissing@Drop[seq,2],n-4]

MinimumVertexCoverCount

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

MinimumVertexDegree

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

MolecularTopologicalIndex

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

FindLinearRecurrence[seq

FindSequenceFunction[seq,n-2]//Factor

Nonhamiltonian

Table[GraphData[{"Dipyramid",n},"Nonhamiltonian"],{n,3,20}]

OddChordlessCycleCount

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

PathCount

seq=Table[GraphData[{"Dipyramid",n},"PathCount"],{n,3,20}]

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

PathPolynomial

(poly=Factor[Table[GraphData[{"Dipyramid",n},"PathPolynomial"],{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[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

PentagonCount

seq=Table[GraphData[{"Dipyramid",n},"PentagonCount"],{n,3,20}]

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

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

ProjectivePlaneCrossingNumber

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

Radius

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

RankPolynomial

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

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

Simplify[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]]

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

RectilinearCrossingNumber

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

ReliabilityPolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"ReliabilityPolynomial"],{n,k0=3,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]

FullSimplify[poly2-poly]

ShannonCapacity

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

SigmaPolynomial

(ChromaticPolynomial known)

(poly=Factor@Table[GraphData[{"Dipyramid",n},"SigmaPolynomial"],{n,k0=3,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]

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

FullSimplify[%-poly]

Skewness

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

SpanningTreeCount

A006235

seq=Table[GraphData[{"Dipyramid",n},"SpanningTreeCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

SquareCount

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

FindSequenceFunction[seq,n-2]

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

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

StabilityIndex

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

(seq=Table[StabilityIndex@DipyramidalGraph[n],{n,3,40}])//Timing

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

coef=FindLinearRecurrence[seq]

Length[coef]

Take[seq,Length[coef]]

LinearRecurrence[{0,4,0,0,0,-10,0,0,0,4,0,-1},{-2,9,14,13,38,68,170,189,538,625,1762,1856},20]

RSolve[{a[n]==4a[n-2]-10a[n-6]+4a[n-10]-a[n-12],a[]=XXX},a[n],n]

Options[FindGeneratingFunction]

gf=(x^3)FindGeneratingFunction[seq,x,ValidationLength->8]

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

TopologicalIndex

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

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

ToroidalCrossingNumber

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

TotalDominatingSetCount

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

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

TotalDominationNumber

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

TotalDominationPolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"TotalDominationPolynomial"],{n,k0=3,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]

Traceable

Table[GraphData[{"Dipyramid",n},"Traceable"],{n,3,20}]

Triameter

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

FindSequenceFunction[DeleteMissing@seq,n-2]

TriangleCount

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

FindSequenceFunction[seq,n-2]

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

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

TuttePolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"TuttePolynomial"],{n,k0=3,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}]

Refine[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]

FullSimplify[poly2-poly]

Untraceable

Table[GraphData[{"Dipyramid",n},"Untraceable"],{n,3,20}]

VertexConnectivity

Table[GraphData[{"Dipyramid",n},"VertexConnectivity"],{n,3,20}]

VertexCoverCount

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

FindSequenceFunction[seq,n-2]

Table[LucasL[n]+3,{n,3,20}]

VertexCoverNumber

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

FindSequenceFunction[seq,n-2]//FullSimplify

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

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

VertexCount

seq=Table[GraphData[{"Dipyramid",n},"V"],{n,3,20}]

FindSequenceFunction[seq,n-2]

VertexCoverPolynomial

(poly=Factor@Table[GraphData[{"Dipyramid",n},"VertexCoverPolynomial"],{n,k0=3,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]]

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

poly2=Table[LinearRecurrence[{x^2,2 x^3,x^4},{x^2,x^3 (4+x),x^4 (3+6 x+x^2)},{n}][[1]],{n,k0,20}]

FullSimplify[poly2-poly]

VertexDegrees

seq=Table[GraphData[{"Dipyramid",n},"VertexDegrees"],{n,3,10}]

WienerIndex

A059100

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

FindSequenceFunction[seq,n-2]//Factor

WienerSumIndex

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

(seq=Table[WienerSumIndex@DipyramidalGraph[n],{n,3,40}])//Timing

FindSequenceFunction[Drop[seq,3],n-5]//Head//Timing

FindLinearRecurrence[Drop[seq,3]]//Head//Timing

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

GraphData

GraphDataString

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

Do[WriteString[file,GraphDataString[
System`Graph[Range[n+2],EdgeList[g3d=DipyramidalGraphFromPolyhedron[n]]],
"StandardName"->{"Dipyramid",n},
"AlternateStandardNames"->{{"Bipyramid",n}},
"Name"->ToString[n]<>"\[Hyphen]dipyramidal graph",
"AlternateNames"->{ToString[n]<>"\[Hyphen]bipyramidal graph"},
"Classes"->{"Dipyramid"},
"NotationRules"->{"Dypyramid"->n},
"Information"->"DipyramidalGraph",
"EmbeddingClasses3D"->{Union[{"Polyhedral","Primary"},If[n<6,{"UnitDistance","Integral"},{}]]},
"Embeddings3D"->{GraphEmbedding[g3d]},
TimeConstraint->60,
Debug->True
]],
{n,7,20}]

Close[file]