Triangular Snake Graph

Author

Eric W. Weisstein
June 8, 2019

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

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

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

Figure

GraphicsRow[Table[Show[StyleGraphs[TriangularSnakeGraph[n]],PlotLabel->Style[Subscript["TS",n],Directive[Black,Italic,FontFamily->"Times"]]],{n,1,9,2}],Alignment->{Center,Bottom},Dividers->All,ImageSize->500]

Special cases

TextGrid[Table[{n,RecognizeGraph@TriangularSnakeGraph[n]},{n,1,13,2}],Dividers->All]//TraditionalForm

GraphData["ButterflyGraph","Graph","All"]

GraphData[{"TriangularSnake",7},"Graph","All"]

Properties

Acyclic

Table[GraphData[{"TriangularSnake",n},"Acyclic"],{n,1,19,2}]

AdjacencyMatrixCount

seq=Table[GraphData[{"TriangularSnake",n},"AdjacencyMatrixCount"],{n,1,19,2}]

Table[((n!)/(Piecewise[{{1,n==1},{6,n==3}},8])),{n,1,19,2}]

Anarboricity

seq=Table[GraphData[{"TriangularSnake",n},"Anarboricity"],{n,1,19,2}]

Arboricity

seq=Table[GraphData[{"TriangularSnake",n},"Arboricity"],{n,1,19,2}]

ArcTransitive

Table[GraphData[{"TriangularSnake",n},"ArcTransitive"],{n,1,19,2}]

ArcTransitivity

Table[GraphData[{"TriangularSnake",n},"ArcTransitivity"],{n,1,19,2}]

AutomorphismCount

seq=Table[GraphData[{"TriangularSnake",n},"AutomorphismCount"],{n,1,19,2}]

BalabanIndex

seq=Table[GraphData[{"TriangularSnake",n},"BalabanIndex"],{n,1,19,2}]

Bandwidth

seq=Table[GraphData[{"TriangularSnake",n},"Bandwidth"],{n,1,19,2}]

BridgeCount

seq=Table[GraphData[{"TriangularSnake",n},"BridgeCount"],{n,1,19,2}]

BurningNumber

seq=Table[GraphData[{"TriangularSnake",n},"BurningNumber"],{n,1,19,2}]

CharacteristicPolynomial

Factor@(poly=Table[GraphData[{"TriangularSnake",n},"CharacteristicPolynomial"],{n,k0=1,kmax=19,2}]/.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[{"TriangularSnake",n},"ChordCount"],{n,1,19,2}]

Chordless

seq=Table[GraphData[{"TriangularSnake",n},"Chordless"],{n,1,19,2}]

ChordlessCycleCount

seq=Table[GraphData[{"TriangularSnake",n},"ChordlessCycleCount"],{n,1,19,2}]

Chords

Length/@Table[GraphData[{"TriangularSnake",n},"Chords"],{n,1,19,2}]

ChromaticInvariant

seq=Table[GraphData[{"TriangularSnake",n},"ChromaticInvariant"],{n,1,19,2}]

ChromaticNumber

seq=Table[GraphData[{"TriangularSnake",n},"ChromaticNumber"],{n,1,19,2}]

ChromaticPolynomial

Factor@(poly=Table[GraphData[{"TriangularSnake",n},"ChromaticPolynomial"],{n,k0=1,kmax=19,2}]/.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[{"TriangularSnake",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[{"TriangularSnake",n},"Circumference"],{n,1,19,2}]

Classes

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

GraphDataClassString["TriangularSnake"]

CliqueCount

seq=Table[GraphData[{"TriangularSnake",n},"CliqueCount"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Factor

CliqueCoveringNumber

seq=Table[GraphData[{"TriangularSnake",n},"CliqueCoveringNumber"],{n,1,19,2}]

CliquePolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"CliquePolynomial"][x],{n,k0=1,kmax=19,2}])//Column

CliqueNumber

seq=Table[GraphData[{"TriangularSnake",n},"CliqueNumber"],{n,1,19,2}]

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"TriangularSnake",n},"ComplementOddChordlessCycleCount"],{n,1,19,2}]

Table[Graph[Range[n],EdgeList[GraphComplement@TriangularSnakeGraph[n]]],{n,1,9,2}]

Print[{#,FindOddChordlessCycle[System`GraphComplement[GraphData[#]],Method->"FindCycle"]//Timing}]&/@Table[{"TriangularSnake",n},{n,9,19,2}];

ConnectedDominatingSetCount

seq=Table[GraphData[{"TriangularSnake",n},"ConnectedDominatingSetCount"],{n,1,19,2}]

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

ConnectedDominationNumber

seq=Table[GraphData[{"TriangularSnake",n},"ConnectedDominationNumber"],{n,1,19,2}]

ConnectedDominationPolynomial

(poly=Table[GraphData[{"TriangularSnake",n},"ConnectedDominationPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])//Factor//Column

ConnectedInducedSubgraphCount

A308579

seq=Table[GraphData[{"TriangularSnake",n},"ConnectedInducedSubgraphCount"],{n,1,19,2}]

FindSequenceFunction[seq,n]//Factor

Table[(9 2^n-6n-10)/2,{n,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{4,-5,2},{1,7,22},40]

gf=x FindGeneratingFunction[seq,x]

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

ConnectedInducedSubgraphPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"ConnectedInducedSubgraphPolynomial"],{n,k0=1,19,2}]/.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]

CrossingNumber

seq=Table[GraphData[{"TriangularSnake",n},"CrossingNumber"],{n,1,19,2}]

CycleCount

seq=Table[GraphData[{"TriangularSnake",n},"CycleCount"],{n,1,19,2}]

CyclePolynomial

Factor@(poly=Table[GraphData[{"TriangularSnake",n},"CyclePolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])

Cyclic

Table[GraphData[{"TriangularSnake",n},"Cyclic"],{n,1,19,2}]

CyclomaticNumber

seq=Table[GraphData[{"TriangularSnake",n},"CyclomaticNumber"],{n,1,19,2}]

DetourIndex

seq=Table[GraphData[{"TriangularSnake",n},"DetourIndex"],{n,1,19,2}]

FindSequenceFunction[seq,n]//Factor

DetourPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"DetourPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[Rest@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]

Diameter

seq=Table[GraphData[{"TriangularSnake",n},"Diameter"],{n,1,19,2}]

DistancePolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"DistancePolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[Rest@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[{"TriangularSnake",n},"DistinguishingNumber"],{n,1,19,2}]

DomaticNumber

seq=Table[GraphData[{"TriangularSnake",n},"DomaticNumber"],{n,1,19,2}]

Do[Print[{{"TriangularSnake",n},DomaticNumber[TriangularSnakeGraph[n],Debug->False]//Timing}],{n,1,19,2}]

DominationNumber

seq=Table[GraphData[{"TriangularSnake",n},"DominationNumber"],{n,1,19,2}]

DominationPolynomial

(poly=Factor[Table[GraphData[{"TriangularSnake",n},"DominationPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x]])//Column

CoefficientList[Take[poly,5],x]

coef=Factor/@FindLinearRecurrence[Rest@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

A007484

seq=Table[GraphData[{"TriangularSnake",n},"DominatingSetCount"],{n,1,19,2}]

seq=LinearRecurrence[{3,2},{2,7},40]

FindLinearRecurrence[seq]

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

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

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

gf=FindGeneratingFunction[DeleteMissing@seq,x]

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

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

EdgeChromaticNumber

seq=Table[GraphData[{"TriangularSnake",n},"EdgeChromaticNumber"],{n,1,19,2}]

EdgeConnectivity

Table[GraphData[{"TriangularSnake",n},"EdgeConnectivity"],{n,1,19,2}]

EdgeCount

seq=Table[GraphData[{"TriangularSnake",n},"M"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Factor

EdgeCoverCount

A005319

seq=Table[GraphData[{"TriangularSnake",n},"EdgeCoverCount"],{n,1,19,2}]

FullSimplify[FindSequenceFunction[DeleteMissing@seq,(n+1)/2],n∈Integers]

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

coef=FindLinearRecurrence[DeleteMissing@seq]

Length@coef

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

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

LinearRecurrence[{6,-1},{0,4},22]

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

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

EdgeCoverNumber

seq=Table[GraphData[{"TriangularSnake",n},"EdgeCoverNumber"],{n,1,19,2}]

EdgeCoverPolynomial

(poly=Factor[Table[GraphData[{"TriangularSnake",n},"EdgeCoverPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x]])//Column

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

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

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]

EulerianCycleCount

seq=Table[GraphData[{"TriangularSnake",n},"EulerianCycleCount"],{n,1,19,2}]

FindSequenceFunction[Rest@seq,(n+1)/2-1]//Simplify

FaceCount

seq=Table[GraphData[{"TriangularSnake",n},"FaceCount"],{n,1,19,2}]

FlowPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"FlowPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])//Column

FractionalChromaticNumber

seq=Table[GraphData[{"TriangularSnake",n},"FractionalChromaticNumber"],{n,1,19,2}]

FractionalCliqueNumber

seq=Table[GraphData[{"TriangularSnake",n},"FractionalCliqueNumber"],{n,1,19,2}]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"TriangularSnake",n},"FractionalEdgeChromaticNumber"],{n,1,19,2}]

Girth

seq=Table[GraphData[{"TriangularSnake",n},"Girth"],{n,1,19,2}]

Graceful

Table[GraphData[{"TriangularSnake",n},"Graceful"],{n,1,19,2}]

Table[MatchQ[Mod[n,8],1|3],{n,1,19,2}]

HamiltonDecomposable

seq=Table[GraphData[{"TriangularSnake",n},"HamiltonDecomposable"],{n,1,19,2}]

HamiltonDecompositionCount

seq=Table[GraphData[{"TriangularSnake",n},"HamiltonDecompositionCount"],{n,1,19,2}]

Hamiltonian

Table[GraphData[{"TriangularSnake",n},"Hamiltonian"],{n,1,19,2}]

HamiltonianCycleCount

seq=Table[GraphData[{"TriangularSnake",n},"HamiltonianCycleCount"],{n,1,19,2}]

HamiltonianNumber

Computed for n = 1, 3, ..., 11; inferred beyond

seq=Table[GraphData[{"TriangularSnake",n},"HamiltonianNumber"],{n,1,19,2}]

HamiltonianPathCount

Not in OEIS

seq=Table[GraphData[{"TriangularSnake",n},"HamiltonianPathCount"],{n,1,19,2}]

HamiltonianWalkCount

seq=Table[GraphData[{"TriangularSnake",n},"HamiltonianWalkCount"],{n,1,19,2}]

FindSequenceFunction[DeleteMissing@seq,n]//Factor

Do[Print[{n,Length@FindHamiltonianWalk[GraphData[{"TriangularSnake",n}],All]//Timing}],{n,1,11,2}]

GraphData[{"TriangularSnake",5},"Graph","Labeled"]

GraphData[{"TriangularSnake",5},"HamiltonianWalks"]

GraphData[{"TriangularSnake",7},"Graph","Labeled"]

GraphData[{"TriangularSnake",7},"HamiltonianWalks"]

GraphData[{"TriangularSnake",9},"Graph","Labeled"]

GraphData[{"TriangularSnake",9},"HamiltonianWalks"]

HararyIndex

seq=Table[GraphData[{"TriangularSnake",n},"HararyIndex"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//FullSimplify

Table[-(5/2) (-1+n)+2 (1+n) HarmonicNumber[(1/2) (-1+n)],{n,1,19,2}]

HexagonCount

seq=Table[GraphData[{"TriangularSnake",n},"HexagonCount"],{n,1,19,2}]

IdiosyncraticPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"IdiosyncraticPolynomial"],{n,k0=1,kmax=19,2}]/.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[{"TriangularSnake",n},"IndependenceNumber"],{n,1,19,2}]

IndependencePolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"IndependencePolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])//Column

CoefficientList[Take[poly,4],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]]

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

IndependenceRatio

seq=Table[GraphData[{"TriangularSnake",n},"IndependenceRatio"],{n,1,19,2}]

IndependentEdgeSetCount

seq=Table[GraphData[{"TriangularSnake",n},"IndependentEdgeSetCount"],{n,1,19,2}]

FindSequenceFunction[Rest@seq,(n-1)/2]//Simplify

Table[Piecewise[{{1,n==1}},4 (3^((n-3)/2))],{n,1,19,2}]

IndependentVertexSetCount

seq=Table[GraphData[{"TriangularSnake",n},"IndependentVertexSetCount"],{n,1,19,2}]

FullSimplify[FindSequenceFunction[seq,(n+1)/2],n∈Integers]

IntersectionNumber

seq=Table[GraphData[{"TriangularSnake",n},"IntersectionNumber"],{n,1,19,2}]

IrredundancePolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"IrredundancePolynomial"],{n,k0=1,19,2}]/.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}]

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

seq=Table[GraphData[{"TriangularSnake",n},"IrredundantSetCount"],{n,1,19,2}]

FindSequenceFunction[DeleteMissing@seq,n]

coef=FindLinearRecurrence[DeleteMissing@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]

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,1,19,2}]

KirchhoffIndex

seq=Table[GraphData[{"TriangularSnake",n},"KirchhoffIndex"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Factor

KirchhoffSumIndex

seq=Table[GraphData[{"TriangularSnake",n},"KirchhoffSumIndex"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Factor

LaplacianPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"LaplacianPolynomial"],{n,k0=1,kmax=19,2}]/.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]

LeafCount

seq=Table[GraphData[{"TriangularSnake",n},"LeafCount"],{n,1,19,2}]

Likelihood

seq=Table[GraphData[{"TriangularSnake",n},"Likelihood"],{n,1,19,2}]

LongestCycleCount

seq=Table[GraphData[{"TriangularSnake",n},"LongestCycleCount"],{n,1,19,2}]

LongestPathLength

seq=Table[GraphData[{"TriangularSnake",n},"LongestPathLength"],{n,1,19,2}]

LongestPathCount

seq=Table[GraphData[{"TriangularSnake",n},"LongestPathCount"],{n,1,19,2}]

LovaszNumber

seq=Table[GraphData[{"TriangularSnake",n},"LovaszNumber"],{n,1,19,2}]

MatchingGeneratingPolynomial

Factor@(poly=Table[GraphData[{"TriangularSnake",n},"MatchingGeneratingPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])//Column

CoefficientList[Take[poly,5],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]]

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

MatchingNumber

seq=Table[GraphData[{"TriangularSnake",n},"MatchingNumber"],{n,1,19,2}]

MatchingPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"MatchingPolynomial"],{n,k0=1,kmax=19,2}]/.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}]//FullSimplify

MaximalCliqueCount

seq=Table[GraphData[{"TriangularSnake",n},"MaximalCliqueCount"],{n,1,19,2}]

MaximalIndependencePolynomial

(poly=Table[GraphData[{"TriangularSnake",n},"MaximalIndependencePolynomial"],{n,k0=1,19,2}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[Rest@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}]//FullSimplify

MaximalIndependentEdgeSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MaximalIndependentEdgeSetCount"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//FullSimplify

InputForm[%]

gf=x FindGeneratingFunction[seq,x]

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

MaximalIndependentVertexSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MaximalIndependentVertexSetCount"],{n,1,19,2}]

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

Table[Piecewise[{{1,n==1}},2 Fibonacci[(1/2) (-1+n)]+LucasL[(1/2) (-1+n)]],{n,1,19,2}]

MaximalIrredundantSetCount

Tribonacci numbers

A000213

seq=Table[GraphData[{"TriangularSnake",n},"MaximalIrredundantSetCount"],{n,1,19,2}]

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

MaximumCliqueCount

seq=Table[GraphData[{"TriangularSnake",n},"MaximumCliqueCount"],{n,1,19,2}]

MaximumIndependentEdgeSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MaximumIndependentEdgeSetCount"],{n,1,19,2}]

MaximumIndependentVertexSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MaximumIndependentVertexSetCount"],{n,1,19,2}]

MaximumIrredundantSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MaximumIrredundantSetCount"],{n,1,19,2}]

MaximumLeafNumber

seq=Table[GraphData[{"TriangularSnake",n},"MaximumLeafNumber"],{n,1,19,2}]

MaximumVertexDegree

seq=Table[GraphData[{"TriangularSnake",n},"MaximumVertexDegree"],{n,1,19,2}]

MeanDistance

seq=Table[GraphData[{"TriangularSnake",n},"MeanDistance"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Factor

MinimalDominatingSetCount

Tribonacci numbers

A000213

seq=Table[GraphData[{"TriangularSnake",n},"MinimalDominatingSetCount"],{n,1,19,2}]

MinimalDominationPolynomial

(poly=Table[GraphData[{"TriangularSnake",n},"MinimalDominationPolynomial"],{n,k0=1,19,2}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[Rest@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}]//FullSimplify

MinimalEdgeCoverCount

A308589

seq=Table[GraphData[{"TriangularSnake",n},"MinimalEdgeCoverCount"],{n,1,19,2}]

FindSequenceFunction[DeleteMissing@seq,n]

InputForm[%]

f1=-1-#1-2*#1^2+#1^3&;
f2=-25+82*#1-87*#1^2+87*#1^3&;
pos={1,2,3};

(an=ToNumberField[Root[f2,#],Root[f1,pos[[#]]]]&/@Range[3])//InputForm

coeffs=an[[All,-1]]

SameQ@@coeffs

RootSum[f1,Evaluate[((#)^(n+Range[Length[pos]]-1)).an[[1,2]]]&]

Table[-RootSum[-1-#1-2 ((#1)^2)+((#1)^3)&,-43 ((#1)^n)-99 ((#1)^(n+1))+40 ((#1)^(n+2))&]/87,{n,50}]

coef=FindLinearRecurrence[DeleteMissing@seq]

LinearRecurrence[{2,1,1},{0,3,7},20]

FindSequenceFunction[seq,n]

gf=x Factor@FindGeneratingFunction[seq,x]

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

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

InputForm[%]

MinimalTotalDominatingSetCount

A308591

seq=Table[GraphData[{"TriangularSnake",n},"MinimalTotalDominatingSetCount"],{n,1,19,2}]

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

coef=FindLinearRecurrence[DeleteMissing@seq]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

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

MinimumCoveringsByMaximalCliquesCount

seq=Table[GraphData[{"TriangularSnake",n},"MinimumCoveringsByMaximalCliquesCount"],{n,1,19,2}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MinimumConnectedDominatingSetCount"],{n,1,19,2}]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"TriangularSnake",n},"MinimumDistinguishingLabelingCount"],{n,1,19,2}]

FindSequenceFunction[DeleteMissing@seq,n]

FindGeneratingFunction[DeleteCases[seq,_Missing],x]

MinimumDominatingSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MinimumDominatingSetCount"],{n,1,19,2}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"TriangularSnake",n},"MinimumEdgeCoverCount"],{n,1,19,2}]

FindSequenceFunction[DeleteMissing@seq,(n+1)/2]//Factor

MinimumTotalDominatingSetCount

seq=Table[GraphData[{"TriangularSnake",n},"MinimumTotalDominatingSetCount"],{n,1,19,2}]

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

MinimumVertexCoverCount

seq=Table[GraphData[{"TriangularSnake",n},"MinimumVertexCoverCount"],{n,1,19,2}]

MinimumVertexDegree

seq=Table[GraphData[{"TriangularSnake",n},"MinimumVertexDegree"],{n,1,19,2}]

MinorCount

seq=Table[GraphData[{"TriangularSnake",n},"MinorCount"],{n,1,19,2}]

FindLinearRecurrence[DeleteMissing[seq]]

FindSequenceFunction[DeleteMissing[seq],n]

FindGeneratingFunction[DeleteMissing[seq],x]

Do[Print[{GraphData[gn={"TriangularSnake",n},"#"],Length@GraphMinors[GraphData[gn]]//Timing}],{n,3,20,2}]

MolecularTopologicalIndex

seq=Table[GraphData[{"TriangularSnake",n},"MolecularTopologicalIndex"],{n,1,19,2}]

FindLinearRecurrence[seq]

FindSequenceFunction[Rest@seq,n]//Factor

Nonhamiltonian

Table[GraphData[{"TriangularSnake",n},"Nonhamiltonian"],{n,1,19,2}]

OddChordlessCycleCount

seq=Table[GraphData[{"TriangularSnake",n},"OddChordlessCycleCount"],{n,1,19,2}]

PathCount

A308585

seq=Table[GraphData[{"TriangularSnake",n},"PathCount"],{n,1,19,2}]

FindSequenceFunction[DeleteMissing@seq,n]//Simplify

Table[2^(3+n)-10n-6,{n,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{4,-5,2},{0,6,28},20]

gf=x FindGeneratingFunction[seq,x]

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

PathPolynomial

(poly=Factor[Table[GraphData[{"TriangularSnake",n},"PathPolynomial"],{n,k0=1,kmax=19,2}]/.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]

PentagonCount

seq=Table[GraphData[{"TriangularSnake",n},"PentagonCount"],{n,1,19,2}]

Perfect

seq=Table[GraphData[{"TriangularSnake",n},"Perfect"],{n,1,19,2}]

Planar

seq=Table[GraphData[{"TriangularSnake",n},"Planar"],{n,1,19,2}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"TriangularSnake",n},"ProjectivePlaneCrossingNumber"],{n,1,19,2}]

Radius

seq=Table[GraphData[{"TriangularSnake",n},"Radius"],{n,1,19,2}]

RankPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"RankPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x,y])//Column

RectilinearCrossingNumber

seq=Table[GraphData[{"TriangularSnake",n},"RectilinearCrossingNumber"],{n,1,19,2}]

ReliabilityPolynomial

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

ShannonCapacity

seq=Table[GraphData[{"TriangularSnake",n},"ShannonCapacity"],{n,1,19,2}]

SigmaPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"SigmaPolynomial"],{n,k0=1,kmax=19,2}]/.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[{"TriangularSnake",n},"Skewness"],{n,1,19,2}]

SpanningTreeCount

seq=Table[GraphData[{"TriangularSnake",n},"SpanningTreeCount"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//FullSimplify

SquareCount

seq=Table[GraphData[{"TriangularSnake",n},"SquareCount"],{n,1,19,2}]

StabilityIndex

seq=Table[GraphData[{"TriangularSnake",n},"StabilityIndex"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]

FindGeneratingFunction[seq,x]

TopologicalIndex

seq=Table[GraphData[{"TriangularSnake",n},"TopologicalIndex"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]

FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

seq=Table[GraphData[{"TriangularSnake",n},"ToroidalCrossingNumber"],{n,1,19,2}]

TotalDominatingSetCount

A308592

seq=Table[GraphData[{"TriangularSnake",n},"TotalDominatingSetCount"],{n,1,19,2}]

FindLinearRecurrence[Rest@seq]

seq=LinearRecurrence[{2,3,2},{1,4,16},40]

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

%19//InputForm

f1=-2-3*#1-2*#1^2+#1^3&;
f2=-81+288*#1-305*#1^2+122*#1^3&;
pos={1,3,2};

(an=ToNumberField[Root[f2,#],Root[f1,pos[[#]]]]&/@Range[3])//InputForm

coeffs=an[[All,-1]]

SameQ@@coeffs

RootSum[f1,Evaluate[((#)^(n+Range[Length[pos]]-1)).an[[1,2]]]&]

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

gf=x FindGeneratingFunction[seq,x]

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

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

TotalDominationNumber

seq=Table[GraphData[{"TriangularSnake",n},"TotalDominationNumber"],{n,1,19,2}]

TotalDominationPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"TotalDominationPolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[Rest@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[{"TriangularSnake",n},"Traceable"],{n,1,19,2}]

Triameter

seq=Table[GraphData[{"TriangularSnake",n},"Triameter"],{n,1,19,2}]

TriangleCount

seq=Table[GraphData[{"TriangularSnake",n},"TriangleCount"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Simplify

TuttePolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"TuttePolynomial"],{n,k0=1,kmax=19,2}]/.f_Function:>f[x,y])//Column

Untraceable

Table[GraphData[{"TriangularSnake",n},"Untraceable"],{n,1,19,2}]

VertexConnectivity

Table[GraphData[{"TriangularSnake",n},"VertexConnectivity"],{n,1,19,2}]

VertexCoverCount

seq=Table[GraphData[{"TriangularSnake",n},"VertexCoverCount"],{n,1,19,2}]

FullSimplify[FindSequenceFunction[seq,(n+1)/2],n∈Integers]

VertexCoverNumber

seq=Table[GraphData[{"TriangularSnake",n},"VertexCoverNumber"],{n,1,19,2}]

VertexCount

seq=Table[GraphData[{"TriangularSnake",n},"V"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]

VertexCoverPolynomial

(poly=Factor@Table[GraphData[{"TriangularSnake",n},"VertexCoverPolynomial"],{n,k0=1,kmax=19,2}]/.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}]

VertexDegrees

(seq=Table[GraphData[{"TriangularSnake",n},"VertexDegrees"],{n,1,19,2}])//Column

WienerIndex

seq=Table[GraphData[{"TriangularSnake",n},"WienerIndex"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Factor

WienerSumIndex

seq=Table[GraphData[{"TriangularSnake",n},"WienerSumIndex"],{n,1,19,2}]

FindSequenceFunction[seq,(n+1)/2]//Factor

Construction

TriangularSnakeGraph[9]

GraphData

GraphDataString

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

Do[WriteString[file,GraphDataString[TriangularSnakeGraph[n],
"StandardName"->{"TriangularSnake",n},
"Name"->ToString[n]<>"\[Hyphen]triangular snake graph",
"Information"->"TriangularSnakeGraph",
"Notation"->Subscript["TS",n],
"NotationRules"->{"TriangularSnake"->n},
"Classes"->{"Graceful","Matchstick","UnitDistance"},
"Skip"->{"ComplementOddChordlessCycle","DomaticNumber"},
Debug->True,
TimeConstraint->10
]],{n,15,19,2}]

Close[file]