Trapezohedral Graph

Author

Eric W. Weisstein
August 2, 2023

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

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

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

Graphic

Graphs.m CircularEmbedding

GraphicsGrid[Partition[Table[Show[StyleGraphs@TrapezohedralGraph[n,GraphLayout->"CircularEmbedding"],PlotLabel->Style[Row[{Style["n",Italic]," == ",n}],Directive[14,Black,FontFamily->"Times"]]],{n,3,10}],UpTo[4]],ImageSize->700,Dividers->All]

Graphs.m PlanarEmbedding

GraphicsGrid[Partition[Table[Show[StyleGraphs@TrapezohedralGraph[n,GraphLayout->"PlanarEmbedding"],PlotLabel->Style[Row[{Style["n",Italic]," == ",n}],Directive[14,Black,FontFamily->"Times"]]],{n,3,10}],UpTo[4]],ImageSize->700,Dividers->All]

Default (sprint-electrical) embeddings

GraphicsGrid[Partition[Table[Show[StyleGraphs@Graph[EdgeList[TrapezohedralGraph[n]]],PlotLabel->Style[Row[{Style["n",Italic]," == ",n}],Directive[14,Black,FontFamily->"Times"]]],{n,3,10}],UpTo[4]],ImageSize->700,Dividers->All]

Properties

Acyclic

Entity["Graph",{"Trapezohedron",n}]["Acyclic"]

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

AdjacencyMatrixCount

Entity["Graph",{"Trapezohedron",n}]["AdjacencyMatrixCount"]

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

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

Table[Piecewise[{{840,n==3}},(2 n+1)(n+1) Gamma[2 n]],{n,3,20}]

AlgebraicConnectivity

Entity["Graph",{"Trapezohedron",n}]["AlgebraicConnectivity"]

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

Laplacian polynomial is known as a complicated expression involving powers that might be hard to find 2nd root of:

seq2=Table[Module[{x},Module[{a=2+(x-5) (x-1)-(x-3) Sqrt[(x-5) (x-1)],b=2+(x-5) (x-1)+(x-3) Sqrt[(x-5) (x-1)]},(*TODO:closed form?*)SortBy[x/. Solve[((a^n+b^n-2^(n+1)) (x-n-1) x (x^2-(n+5) x+4 n))/((x-5) (x-1) 2^n)==0,x],N][[2]]]],{n,3,20}]

seq-seq2//RootReduce

AlmostHamiltonian

Entity["Graph",{"Trapezohedron",n}]["AlmostHamiltonian"]

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

Anarboricity

Entity["Graph",{"Trapezohedron",n}]["Anarboricity"]

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

Antipodal

Entity["Graph",{"Trapezohedron",n}]["Antipodal"]

Table[GraphData[{"Trapezohedron",n},"Antipodal"],{n,3,20}]

Apex

Entity["Graph",{"Trapezohedron",n}]["Apex"]

Table[GraphData[{"Trapezohedron",n},"Apex"],{n,3,20}]

ApexCount

Entity["Graph",{"Trapezohedron",n}]["ApexCount"]

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

FindSequenceFunction[seq,n-2]

Arboricity

Entity["Graph",{"Trapezohedron",n}]["Arboricity"]

Inferred for n > 8:

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

ArcTransitive

Entity["Graph",{"Trapezohedron",n}]["ArcTransitive"]

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

ArcTransitivity

Entity["Graph",{"Trapezohedron",n}]["ArcTransitivity"]

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

ArticulationVertexCount

Entity["Graph",{"Trapezohedron",n}]["ArticulationVertexCount"]

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

AutomorphismCount

Entity["Graph",{"Trapezohedron",n}]["AutomorphismCount"]

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

FindSequenceFunction[Rest@seq,n-3]

BalabanIndex

Entity["Graph",{"Trapezohedron",n}]["BalabanIndex"]

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

Table[(1/2)(1/(2n))GraphData[{"Trapezohedron",n},"BalabanIndex"],{n,3,10}]//Expand//Column

{255,6^2 11,9^2 7 ,16^2 3}

FindSequenceFunction[%,n-3]//Factor

seq2=Table[4n((1/(5n-3))+(1/(Sqrt[3 (5n-3)(n+1)]))),{n,3,20}]

seq-seq2//Expand//Union

Bandwidth

Entity["Graph",{"Trapezohedron",n}]["Bandwidth"]

Inferred for n > 6:

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

Bicolorable

Entity["Graph",{"Trapezohedron",n}]["Bicolorable"]

Table[GraphData[{"Trapezohedron",n},"Bicolorable"],{n,3,20}]

Biconnected

Entity["Graph",{"Trapezohedron",n}]["Biconnected"]

Table[GraphData[{"Trapezohedron",n},"Biconnected"],{n,3,20}]

Bicubic

Entity["Graph",{"Trapezohedron",n}]["Bicubic"]

Table[GraphData[{"Trapezohedron",n},"Bicubic"],{n,3,20}]

Bipartite

Entity["Graph",{"Trapezohedron",n}]["Bipartite"]

Table[GraphData[{"Trapezohedron",n},"Bipartite"],{n,3,20}]

BipartiteDimension

Entity["Graph",{"Trapezohedron",n}]["BipartiteDimension"]

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

BipartiteDoubleGraphName

Entity["Graph",{"Trapezohedron",n}]["BipartiteDoubleGraphName"]

seq=Table[GraphData[{"Trapezohedron",n},"BipartiteDoubleGraphName"],{n,3,20}]

BipartiteDoubleGraph[GraphData[{"Trapezohedron",3}]]//RecognizeGraph

Table[RecognizeGraph/@ConnectedGraphComponents[BipartiteDoubleGraph[TrapezohedralGraph[n]]],{n,3,10}]//Column

Biplanar

Entity["Graph",{"Trapezohedron",n}]["Biplanar"]

Table[GraphData[{"Trapezohedron",n},"Biplanar"],{n,3,20}]

Block

Entity["Graph",{"Trapezohedron",n}]["Block"]

seq=Table[GraphData[{"Trapezohedron",n},"Block"],{n,3,20}]

BlockCount

Entity["Graph",{"Trapezohedron",n}]["BlockCount"]

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

BridgeCount

Entity["Graph",{"Trapezohedron",n}]["BridgeCount"]

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

Bridged

Entity["Graph",{"Trapezohedron",n}]["Bridged"]

Table[GraphData[{"Trapezohedron",n},"Bridged"],{n,3,20}]

BroadcastTime

Entity["Graph",{"Trapezohedron",n}]["BroadcastTime"]

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

BurningNumber

Entity["Graph",{"Trapezohedron",n}]["BurningNumber"]

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

CanonicalPolyhedronDistinctEdgeLengthCount

Entity["Graph",{"Trapezohedron",n}]["CanonicalPolyhedronDistinctEdgeLengthCount"]

seq=Table[GraphData[{"Trapezohedron",n},"CanonicalPolyhedronDistinctEdgeLengthCount"],{n,3,20}]

Center

Entity["Graph",{"Trapezohedron",n}]["Center"]

Table[Entity["Graph",{"Trapezohedron",n}]["Center"]==Range[2n+2],{n,3,20}]//Union

Table[GraphData[{"Trapezohedron",n},"Center"]==Range[2n+2],{n,3,20}]//Union

CharacteristicPolynomial

Entity["Graph",{"Trapezohedron",n}]["CharacteristicPolynomial"][x]

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

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

poly==Factor@Table[CharacteristicPolynomial[AdjacencyMatrix[TrapezohedralGraph[n]],x],{n,k0=3,20}]

poly2=Table[CharacteristicPolynomial[AdjacencyMatrix[TrapezohedralGraph[n]],x],{n,k0=3,30}];

coef=Factor/@FindLinearRecurrence[poly2]

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

Length[coef]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n]]

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

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

CoefficientList[%,x^2]

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

Table[(( ((n^2)-2 (2+n) (x^2)+(x^4)) (-(2^(1+n))(2^(-n))+2ChebyshevT[2n,x/2]))/(-4+(x^2))),{n,3,20}]-poly//Expand//Factor

(2^(1+n))(2^(-n))

Factor[((x^4)-2 (2+n) (x^2)+(n^2))]

Table[(( 2(n-2 x-(x^2)) (n+2 x-(x^2))(ChebyshevT[2n,x/2]-1))/((x^2)-4)),{n,3,20}]-poly//Expand//Factor

CheegerConstant

Entity["Graph",{"Trapezohedron",n}]["CheegerConstant"]

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

Chordal

Entity["Graph",{"Trapezohedron",n}]["Chordal"]

Table[GraphData[{"Trapezohedron",n},"Chordal"],{n,3,20}]

ChordCount

Entity["Graph",{"Trapezohedron",n}]["ChordCount"]

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

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

ChordlessCycleCount

Entity["Graph",{"Trapezohedron",n}]["ChordlessCycleCount"]

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

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

ChordlessCyclePolynomial

Entity["Graph",{"Trapezohedron",n}]["ChordlessCyclePolynomial"][x]

(seq=Table[GraphData[{"Trapezohedron",n},"ChordlessCyclePolynomial"],{n,3,20}]/.f_Function:>f[x])//Column

FindSequenceFunction[DeleteMissing@seq,n-2]

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

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

%/.x->1//Factor

ChromaticInvariant

Entity["Graph",{"Trapezohedron",n}]["ChromaticInvariant"]

Inferred for n > 13:

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

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

Table[LucasL[2n]-2n-1,{n,3,20}]

ChromaticNumber

Entity["Graph",{"Trapezohedron",n}]["ChromaticNumber"]

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

ChromaticPolynomial

Entity["Graph",{"Trapezohedron",n}]["ChromaticPolynomial"][x]

Inferred for n > 13:

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

Length[coef]

init=Take[poly,Length[coef]]//Expand

LinearRecurrence[coef,init,{-1,2}]

%//Column

LinearRecurrence[{11-8 x+2 (x^2),-((5-4 x+(x^2)) (7-4 x+(x^2))),29-44 x+27 (x^2)-8 (x^3)+(x^4),-(((-2+x))^2)},{(((-1+x))^3) x,x (-17+47 x-51 (x^2)+28 (x^3)-8 (x^4)+(x^5)),x (-133+423 x-572 (x^2)+441 (x^3)-214 (x^4)+66 (x^5)-12 (x^6)+(x^7)),x (-897+3391 x-5679 (x^2)+5648 (x^3)-3732 (x^4)+1716 (x^5)-552 (x^6)+120 (x^7)-16 (x^8)+(x^9))},5]//Expand//Column

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

2^-n x (2^n+2^n (-2+x)^(2 n)-3 2^n x+2^n x^2-(6-4 x+x^2-(-2+x) Sqrt[8+(-4+x) x])^n+x (6-4 x+x^2-(-2+x) Sqrt[8+(-4+x) x])^n+(-1+x) (6-4 x+x^2+(-2+x) Sqrt[8+(-4+x) x])^n)/.n->3//FullSimplify//Expand

FullSimplify[(2^(-n)) x ((2^n)+(2^n) (((-2+x))^(2 n))-3 (2^n) x+(2^n) (x^2)-(((6-4 x+(x^2)-(-2+x) (Sqrt[8+(-4+x) x])))^n)+x (((6-4 x+(x^2)-(-2+x) (Sqrt[8+(-4+x) x])))^n)+(-1+x) (((6-4 x+(x^2)+(-2+x) (Sqrt[8+(-4+x) x])))^n))/.{(6-4 x+(x^2)-(-2+x) (Sqrt[8+(-4+x) x]))->a, (6-4 x+(x^2)+(-2+x) (Sqrt[8+(-4+x) x]))->b}]

poly2=Table[x((( (x-1)((a^n) +(b^n)))/(2^n))+(((x-2))^(2 n))+x(x-3)+1),{n,3,20}]/.{a->6-4 x+(x^2)-(-2+x) (Sqrt[8+(-4+x) x]),b-> (6-4 x+(x^2)+(-2+x) (Sqrt[8+(-4+x) x]))};

poly-poly2//Expand

poly2=Table[With[{a=6-4 x+(x^2)-(-2+x) (Sqrt[8+(-4+x) x]),b= (6-4 x+(x^2)+(-2+x) (Sqrt[8+(-4+x) x]))},x((( (x-1)((a^n) +(b^n)))/(2^n))+(((x-2))^(2 n))+x(x-3)+1)],{n,3,20}];

poly-poly2//Expand

CircuitRank

Entity["Graph",{"Trapezohedron",n}][""]

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

FindSequenceFunction[seq,n-2]//FullSimplify

Circumference

Entity["Graph",{"Trapezohedron",n}]["Circumference"]

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

FindSequenceFunction[seq,n-2]

Classes

Entity["Graph",{"Trapezohedron",n}]["Classes"]//CanonicalName

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

ClawFree

Entity["Graph",{"Trapezohedron",n}]["ClawFree"]

Table[GraphData[{"Trapezohedron",n},"ClawFree"],{n,3,20}]

CliqueCount

Entity["Graph",{"Trapezohedron",n}]["CliqueCount"]

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

FindSequenceFunction[seq,n-2]//Factor

CliqueCoveringNumber

Entity["Graph",{"Trapezohedron",n}]["CliqueCoveringNumber"]

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

FindSequenceFunction[seq,n-2]

CliqueNumber

Entity["Graph",{"Trapezohedron",n}]["CliqueNumber"]

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

CliquePolynomial

Entity["Graph",{"Trapezohedron",n}]["CliquePolynomial"][x]

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

FindSequenceFunction[poly,n-2]//Factor

Coarseness

Entity["Graph",{"Trapezohedron",n}]["Coarseness"]

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

CoboundaryPolynomial

Entity["Graph",{"Trapezohedron",n}]["CoboundaryPolynomial"]

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

FindSequenceFunction[DeleteMissing@poly,n-2]

ComplementGraph

Entity["Graph",{"Trapezohedron",n}]["ComplementGraph"]

seq=Table[GraphData[{"Trapezohedron",n},"ComplementGraph","Name"],{n,3,20}]

ComplementOddChordlessCycleCount

Entity["Graph",{"Trapezohedron",n}]["ComplementOddChordlessCycleCount"]

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

ComplementOddChordlessCyclePolynomial

Entity["Graph",{"Trapezohedron",n}]["ComplementOddChordlessCyclePolynomial"][0]

seq=Table[GraphData[{"Trapezohedron",n},"ComplementOddChordlessCyclePolynomial"],{n,3,20}]/.f_Function:>f[x]

Conductance

Entity["Graph",{"Trapezohedron",n}]["Conductance"]

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

Connected

Entity["Graph",{"Trapezohedron",n}]["Connected"]

seq=Table[GraphData[{"Trapezohedron",n},"Connected"],{n,3,20}]

ConnectedComponentCount

Entity["Graph",{"Trapezohedron",n}]["ConnectedComponentCount"]

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

ConnectedDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["ConnectedDominatingSetCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,5}]

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

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

ConnectedDominationNumber

Entity["Graph",{"Trapezohedron",n}]["ConnectedDominationNumber"]

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

ConnectedDominationPolynomial

Entity["Graph",{"Trapezohedron",n}]["ConnectedDominationPolynomial"]

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

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

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

poly2=Table[XXX,{n,3,20}]

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

Entity["Graph",{"Trapezohedron",n}]["ConnectedInducedSubgraphCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

ConnectedInducedSubgraphPolynomial

Entity["Graph",{"Trapezohedron",n}]["ConnectedInducedSubgraphPolynomial"]

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

(coef=Factor/@FindLinearRecurrence[DeleteMissing@poly])//Timing

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

poly2=Table[XXX,{n,3,20}]

FullSimplify[poly2-poly]

Corank

Entity["Graph",{"Trapezohedron",n}]["Corank"]

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

FindSequenceFunction[seq,n-2]//Factor

CriticalNonplanar

Entity["Graph",{"Trapezohedron",n}]["CriticalNonplanar"]

Table[GraphData[{"Trapezohedron",n},"CriticalNonplanar"],{n,3,20}]

CrossingNumber

Entity["Graph",{"Trapezohedron",n}]["CrossingNumber"]

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

Cubic

Entity["Graph",{"Trapezohedron",n}]["Cubic"]

Table[GraphData[{"Trapezohedron",n},"CriticalNonplanar"],{n,3,20}]

CycleCount

Entity["Graph",{"Trapezohedron",n}]["CycleCount"]

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

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

TraditionalForm[%]

CyclePolynomial

Entity["Graph",{"Trapezohedron",n}]["CyclePolynomial"][x]

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

coef=Factor/@FindLinearRecurrence[poly]

Length[coef]

LinearRecurrence[coef,Take[poly,6],{-1,4}]

LinearRecurrence[{3 (1+(x^2)),-3 (1+3 (x^2)+(x^4)),(1+(x^2)) (1+8 (x^2)+(x^4)),-3 (x^2) (1+3 (x^2)+(x^4)),3 (x^4) (1+(x^2)),-(x^6)},{(x^2),(x^4) (5+2 (x^2)),2 (x^4) (3+8 (x^2)+3 (x^4)),(x^4) (8+28 (x^2)+33 (x^4)+12 (x^6)),(x^4) (10+45 (x^2)+60 (x^4)+56 (x^6)+20 (x^8)),(x^4) (12+66 (x^2)+96 (x^4)+102 (x^6)+85 (x^8)+30 (x^10))},5]//Expand//Column

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

Table[((n (x^4) (-2+(7-2 n) (x^2)+(-1+2 n) (x^4))+(x^(2 n)) (-1+(3+2 n) (x^2)-(1+n) (3+n) (x^4)-(-1+n) (x^6)+(-1+n) n (x^8)))/(((-1+(x^2)))^3)),{n,3,20}]-poly//FullSimplify//Union

Cyclic

Entity["Graph",{"Trapezohedron",n}]["Cyclic"]

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

CyclicEdgeConnectivity

Entity["Graph",{"Trapezohedron",n}]["CyclicEdgeConnectivity"]

Inferred from n > 8:

seq=Table[GraphData[{"Trapezohedron",n},"CyclicEdgeConnectivity"],{n,3,20}]

FindSequenceFunction[seq,n-2]

Degeneracy

Entity["Graph",{"Trapezohedron",n}]["Degeneracy"]

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

DegreeCentralities

Entity["Graph",{"Trapezohedron",n}]["DegreeCentralities"]

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

Table[GraphData[{"Trapezohedron",n},"DegreeCentralities"],{n,3,6}]//Column

Table[Join[ConstantArray[3,2n],{n,n}],{n,3,6}]//Column

Table[GraphData[{"Trapezohedron",n},"DegreeCentralities"],{n,3,20}]==Table[Join[ConstantArray[3,2n],{n,n}],{n,3,20}]

DetourIndex

Entity["Graph",{"Trapezohedron",n}]["DetourIndex"]

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

FindSequenceFunction[seq,n-2]//Factor

DetourPolynomial

Entity["Graph",{"Trapezohedron",n}]["DetourPolynomial"][x]

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

FindSequenceFunction[{46,77,116,163},n-2]//Factor

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

Diameter

Entity["Graph",{"Trapezohedron",n}]["Diameter"]

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

Dimension

Entity["Graph",{"Trapezohedron",n}]["Dimension"]

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

DisorderNumber

Entity["Graph",{"Trapezohedron",n}]["DisorderNumber"]

seq=Table[GraphData[{"Trapezohedron",n},"DisorderNumber"],{n,3,20}]

DistanceHereditary

Entity["Graph",{"Trapezohedron",n}]["DistanceHereditary"]

seq=Table[GraphData[{"Trapezohedron",n},"DistanceHereditary"],{n,3,20}]

DistanceMatrix

Entity["Graph",{"Trapezohedron",n}]["DistanceMatrix"]

MatrixPlot/@Table[GraphData[{"Trapezohedron",n},"DistanceMatrix"],{n,k0=3,10}]

DistancePolynomial

Entity["Graph",{"Trapezohedron",n}]["DistancePolynomial"]

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

<<MathWorld`Graphs`

poly=Table[DistancePolynomial[TrapezohedralGraph[n],x],{n,3,50}];//Timing

coef=FindLinearRecurrence[poly]

Length[coef]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

k0=3;

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

(soln=RSolve[Prepend[Table[p[k+k0-1,x]==poly[[k]],{k,Length[coef]}],ToPolynomialRecurrence[p,x,n,coef]],p[n,x],n])//Timing

(soln2=FullSimplify[soln,n∈PositiveIntegers])//Timing

Factor[(((2^(-n)) (-6+x+(x^2)+n (2+x)) (-((-3+x) (6+x))+n (-6+5 x)) ((2^(1+3 n))-(((x (4+x-(Sqrt[(-2+x) (6+x)]))-2 (2+(Sqrt[(-2+x) (6+x)]))))^n)-(((2 (-2+(Sqrt[(-2+x) (6+x)]))+x (4+x+(Sqrt[(-2+x) (6+x)]))))^n)))/((-2+x) (6+x)))]

poly-Table[-(((2^(-n)) (-18+6 n+3 x-5 n x+(x^2)) (-6+2 n+x+n x+(x^2)) ((2^(1+3 n))-(((x (4+x-(Sqrt[-12+4 x+(x^2)]))-2 (2+(Sqrt[-12+4 x+(x^2)]))))^n)-(((2 (-2+(Sqrt[-12+4 x+(x^2)]))+x (4+x+(Sqrt[-12+4 x+(x^2)]))))^n)))/((-2+x) (6+x))),{n,3,20}]//Expand//Together

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

CoefficientList[%,x]

(gf=FindGeneratingFunction[poly,z])//Head//Timing

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

DistanceRegular

Entity["Graph",{"Trapezohedron",n}]["DistanceRegular"]

Table[GraphData[{"Trapezohedron",n},"DistanceRegular"],{n,3,20}]

DistanceTransitive

Entity["Graph",{"Trapezohedron",n}]["DistanceTransitive"]

Table[GraphData[{"Trapezohedron",n},"DistanceTransitive"],{n,3,20}]

DistinguishingNumber

Entity["Graph",{"Trapezohedron",n}]["DistinguishingNumber"]

Inferred for n > 4:

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

DomaticNumber

Entity["Graph",{"Trapezohedron",n}]["DomaticNumber"]

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

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

DeleteMissing@seq-3

FullSimplify[SeriesCoefficient[1/(1-x^3),{x,0,n}],n∈Integers&&n>0]

FullSimplify[(1/3) (1+2 Cos[((2 n π)/3)])+3]

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

DominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["DominatingSetCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

DominationNumber

Entity["Graph",{"Trapezohedron",n}]["DominationNumber"]

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

DominationPolynomial

Entity["Graph",{"Trapezohedron",n}]["DominationPolynomial"]

(poly=Table[GraphData[{"Trapezohedron",n},"DominationPolynomial"],{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]

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

FullSimplify[poly2-poly]

Doublecross

Entity["Graph",{"Trapezohedron",n}]["Doublecross"]

Table[GraphData[{"Trapezohedron",n},"Doublecross"],{n,3,20}]

Eccentricities

Entity["Graph",{"Trapezohedron",n}]["Eccentricities"]

(seq=Tally/@Table[GraphData[{"Trapezohedron",n},"Eccentricities"],{n,3,20}])//Column

Tally/@Table[ConstantArray[3,2n+2],{n,3,20}]

EccentricityCentralities

Entity["Graph",{"Trapezohedron",n}]["EccentricityCentralities"]

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

Tally/@Table[ConstantArray[1/3,2n+2],{n,3,20}]

EdgeBetweennessCentralities

Entity["Graph",{"Trapezohedron",n}]["EdgeBetweennessCentralities"]

seq=Table[GraphData[{"Trapezohedron",n},"EdgeBetweennessCentralities"],{n,3,20}]

EdgeChromaticNumber

Entity["Graph",{"Trapezohedron",n}]["EdgeChromaticNumber"]

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

FindSequenceFunction[seq,n-2]//FullSimplify

EdgeConnectivity

Entity["Graph",{"Trapezohedron",n}]["EdgeConnectivity"]

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

EdgeCount

Entity["Graph",{"Trapezohedron",n}]["EdgeCount"]

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

FindSequenceFunction[seq,n-2]

EdgeCoverCount

Entity["Graph",{"Trapezohedron",n}]["EdgeCoverCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Timing}],{k,0,4}]

Do[Print[{k,FindLinearRecurrence[Drop[DeleteMissing[seq],k]]//Timing}],{k,0,4}]

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

EdgeCoverNumber

Entity["Graph",{"Trapezohedron",n}]["EdgeCoverNumber"]

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

FindSequenceFunction[seq,n-2]

EdgeCoverPolynomial

Entity["Graph",{"Trapezohedron",n}]["EdgeCoverPolynomial"]

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

coef=Factor/@FindLinearRecurrence[poly]

EdgeCutCount

Entity["Graph",{"Trapezohedron",n}]["EdgeCutCount"]

seq=Table[GraphData[{"Trapezohedron",n},"EdgeCutCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

EdgeCutPolynomial

Entity["Graph",{"Trapezohedron",n}]["EdgeCutPolynomial"]

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

coef=Factor/@FindLinearRecurrence[poly]

EdgeTransitive

Entity["Graph",{"Trapezohedron",n}]["EdgeTransitive"]

seq=Table[GraphData[{"Trapezohedron",n},"EdgeTransitive"],{n,3,20}]

seq==Table[Piecewise[{{True,n==3}},False],{n,3,20}]

EigenvectorCentralities

Entity["Graph",{"Trapezohedron",n}]["EigenvectorCentralities"]

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

Tally/@seq//Column

Eulerian

Entity["Graph",{"Trapezohedron",n}]["Eulerian"]

seq=Table[GraphData[{"Trapezohedron",n},"Eulerian"],{n,3,20}]

EulerianCycleCount

Entity["Graph",{"Trapezohedron",n}]["EulerianCycleCount"]

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

FaceCount

Entity["Graph",{"Trapezohedron",n}]["FaceCount"]

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

FindSequenceFunction[seq,n-2]

FibonacciCube

Entity["Graph",{"Trapezohedron",n}]["FibonacciCube"]

seq=Table[GraphData[{"Trapezohedron",n},"FibonacciCube"],{n,3,20}]

FlowPolynomial

Entity["Graph",{"Trapezohedron",n}]["FlowPolynomial"][x]

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

coef=Factor/@FindLinearRecurrence[poly]

Length[coef]

LinearRecurrence[coef,Take[poly,4],{-1,2}]

LinearRecurrence[coef,{0,(-2+x) (3-4 x+(x^2)),(-2+x) (-1+x) (-32+29 x-9 (x^2)+(x^3)),(-3+x) (-2+x) (-1+x) (71-84 x+41 (x^2)-10 (x^3)+(x^4))},5]//Column

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

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

Take[poly,3]//Expand//Column

FullSimplify[(((2^(-n)) ((2^n)-(((5-(Sqrt[9-4 x])-2 x))^n)-(((5+(Sqrt[9-4 x])-2 x))^n)+(2^n) (((-2+x))^(2 n))+x (-3 (2^n)+(((5-(Sqrt[9-4 x])-2 x))^n)+(((5+(Sqrt[9-4 x])-2 x))^n)+(2^n) x)))/x)/.{(5-(Sqrt[9-4 x])-2 x)->a,(5+(Sqrt[9-4 x])-2 x)->b}]

poly2=Table[With[{a=5-(Sqrt[9-4 x])-2 x,b=5+(Sqrt[9-4 x])-2 x},(((2^(-n)) (x-1)((a^n)+(b^n))+((((x-2))^(2 n))+(x-3) x+1))/x)],{n,3,20}];

poly-poly2//Expand

FractionalArboricity

Entity["Graph",{"Trapezohedron",n}]["FractionalArboricity"]

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

FractionalChromaticNumber

Entity["Graph",{"Trapezohedron",n}]["FractionalChromaticNumber"]

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

FractionalEdgeChromaticNumber

Entity["Graph",{"Trapezohedron",n}]["FractionalEdgeChromaticNumber"]

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

FindSequenceFunction[DeleteMissing@seq,n-2]

Genus

Entity["Graph",{"Trapezohedron",n}]["Genus"]

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

Geodetic

Entity["Graph",{"Trapezohedron",n}]["Geodetic"]

Table[GraphData[{"Trapezohedron",n},"Geodetic"],{n,3,20}]

Girth

Entity["Graph",{"Trapezohedron",n}]["Girth"]

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

GlobalClusteringCoefficient

Entity["Graph",{"Trapezohedron",n}]["GlobalClusteringCoefficient"]

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

Gonality

Entity["Graph",{"Trapezohedron",n}]["Gonality"]

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

Graceful

Entity["Graph",{"Trapezohedron",n}]["Graceful"]

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

GracefulLabelingCount

Entity["Graph",{"Trapezohedron",n}]["GracefulLabelingCount"]

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

HadwigerNumber

Entity["Graph",{"Trapezohedron",n}]["HadwigerNumber"]

Inferred for n > 5:

Table[GraphData[{"Trapezohedron",n},"HadwigerNumber"],{n,3,20}]

HamiltonConnected

Entity["Graph",{"Trapezohedron",n}]["HamiltonConnected"]

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

HamiltonDecomposable

Entity["Graph",{"Trapezohedron",n}]["HamiltonDecomposable"]

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

HamiltonDecompositionCount

Entity["Graph",{"Trapezohedron",n}]["HamiltonDecompositionCount"]

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

Hamiltonian

Entity["Graph",{"Trapezohedron",n}]["Hamiltonian"]

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

HamiltonianCycleCount

Entity["Graph",{"Trapezohedron",n}]["HamiltonianCycleCount"]

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

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

HamiltonianNumber

Entity["Graph",{"Trapezohedron",n}]["HamiltonianNumber"]

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

FindSequenceFunction[seq,n]//Factor

HamiltonianPathCount

Entity["Graph",{"Trapezohedron",n}]["HamiltonianPathCount"]

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

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

2 n (6-7 n+3 (n^2))//TraditionalForm

Table[2 n (6-7 n+3 (n^2)),{n,3,20}]

HamiltonianWalkCount

Entity["Graph",{"Trapezohedron",n}]["HamiltonianWalkCount"]

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

FindSequenceFunction[seq,n-2]//Factor

HamiltonLaceable

Entity["Graph",{"Trapezohedron",n}]["HamiltonLaceable"]

Table[GraphData[{"Trapezohedron",n},"HamiltonLaceable"],{n,3,20}]

HararyIndex

Entity["Graph",{"Trapezohedron",n}]["HararyIndex"]

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

FindSequenceFunction[seq,n-2]//Factor

TraditionalForm[%]

HexagonCount

Entity["Graph",{"Trapezohedron",n}]["HexagonCount"]

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

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

HStarConnected

Entity["Graph",{"Trapezohedron",n}]["HStarConnected"]

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

Hypohamiltonian

Entity["Graph",{"Trapezohedron",n}]["Hypohamiltonian"]

Table[GraphData[{"Trapezohedron",n},"Hypohamiltonian"],{n,3,20}]

Hypotraceable

Entity["Graph",{"Trapezohedron",n}]["Hypotraceable"]

Table[GraphData[{"Trapezohedron",n},"Hypotraceable"],{n,3,20}]

Identity

Entity["Graph",{"Trapezohedron",n}]["Identity"]

Table[GraphData[{"Trapezohedron",n},"Identity"],{n,3,20}]

IdiosyncraticPolynomial

Entity["Graph",{"Trapezohedron",n}]["IdiosyncraticPolynomial"]

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

coef=FindLinearRecurrence[DeleteMissing@poly]//Timing

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

poly2=Table[(x+1)^(n-1) (x+1-n),{n,k0,10}]

FullSimplify[poly2/poly]

IncidenceMatrix

Entity["Graph",{"Trapezohedron",n}]["IncidenceMatrix"]

MatrixPlot/@Table[GraphData[{"Trapezohedron",n},"IncidenceMatrix"],{n,k0=3,kmax=10}]

IndependenceNumber

Entity["Graph",{"Trapezohedron",n}]["IndependenceNumber"]

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

FindSequenceFunction[seq,n-2]

IndependencePolynomial

Entity["Graph",{"Trapezohedron",n}]["IndependencePolynomial"][x]

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

coef=Factor/@FindLinearRecurrence[poly]

Length[coef]

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]

LinearRecurrence[{3 (1+x),-3 (((1+x))^2),1+3 x+4 (x^2)+(x^3),-(x^2) (1+x)},{(1+x) (1+3 x),(1+x) (1+5 x+2 (x^2)),1+8 x+16 (x^2)+8 (x^3)+2 (x^4),1+10 x+29 (x^2)+28 (x^3)+10 (x^4)+2 (x^5)},5]//Expand//Column

CoefficientList[Table[(2^(-n)) ((((1+2 \[FormalX]-(Sqrt[1+4 \[FormalX]])))^n)+(((1+2 \[FormalX]+(Sqrt[1+4 \[FormalX]])))^n)),{n,7}]//Expand,\[FormalX]]

Function[\[FormalX],(\[FormalX]^2)+2 \[FormalX] (((1+\[FormalX]))^n)+(2^(-n)) ((((1+2 \[FormalX]-(Sqrt[1+4 \[FormalX]])))^n)+(((1+2 \[FormalX]+(Sqrt[1+4 \[FormalX]])))^n))][x]

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

Table[x^n LucasL[2n,1/Sqrt[x]],{n,6}]//Expand

poly2=Table[(x^2)+2 x (((1+x))^n)+x^n LucasL[2n,1/Sqrt[x]],{n,3,20}]//Expand;

poly-poly2//Expand

IndependenceRatio

Entity["Graph",{"Trapezohedron",n}]["IndependenceRatio"]

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

IndependentEdgeSetCount

Entity["Graph",{"Trapezohedron",n}]["IndependentEdgeSetCount"]

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-2]

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

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

ExpandAll[Table[(((1-(Sqrt[5])))^n),{n,3}]]

Table[(1/25) (2^(-n)) ((1/(2^n))(((1-(Sqrt[5])))^(2n)) (25-12 (Sqrt[5]) n+5 (n^2))+(1/(2^n))(((1+(Sqrt[5])))^(2n))(25+12 (Sqrt[5]) n+5 (n^2))),{n,3,20}]//Expand//Together

Table[(1/25) (2^(-n)) ((1/(2^n))(((1-(Sqrt[5])))^(2n)) (25-12 (Sqrt[5]) n+5 (n^2))+(1/(2^n))(((1+(Sqrt[5])))^(2n))(25+12 (Sqrt[5]) n+5 (n^2))),{n,3,20}]//Expand//Together

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

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

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

Table[Fibonacci[2n],{n,3,10}]

Table[(1/25) (2^(-n)) (2^(2n))((1/(2^n))(((((1-(Sqrt[5]))/2)))^(2n)) (25-12 (Sqrt[5]) n+5 (n^2))+(1/(2^n))(((((1+(Sqrt[5]))/2)))^(2n))(25+12 (Sqrt[5]) n+5 (n^2))),{n,3,20}]//Expand//Together

Table[(1/25) ((((((1-(Sqrt[5]))/2)))^(2n)) (25-12 (Sqrt[5]) n+5 (n^2))+(((((1+(Sqrt[5]))/2)))^(2n))(25+12 (Sqrt[5]) n+5 (n^2))),{n,3,20}]//Expand//Together

Table[(1/25)(((25+5n^2)((((((1-(Sqrt[5]))/2)))^(2n)) +(((((1+(Sqrt[5]))/2)))^(2n)))+((60 n)/(Sqrt[5]))((((((1+(Sqrt[5]))/2)))^(2n))-(((((1-(Sqrt[5]))/2)))^(2n)) ))),{n,3,20}]//Expand//Together

Table[(1/25)(((25+5n^2)LucasL[2n]+60n Fibonacci[2n])),{n,3,20}]//Expand//Together

FullSimplify[(1/25)(((25+5n^2)LucasL[2n]+60n Fibonacci[2n]))]

IndependentVertexSetCount

Entity["Graph",{"Trapezohedron",n}]["IndependentVertexSetCount"]

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

FullSimplify[FindSequenceFunction[seq,n-2]]

Table[LucasL[2n]+(2^(n+1))+1,{n,3,20}]

IntersectionArray

Entity["Graph",{"Trapezohedron",n}]["IntersectionArray"]

seq=Table[GraphData[{"Trapezohedron",n},"IntersectionArray"],{n,3,20}]

IntersectionNumber

Entity["Graph",{"Trapezohedron",n}]["IntersectionNumber"]

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

IrredundanceNumber

Entity["Graph",{"Trapezohedron",n}]["IrredundanceNumber"]

Inferred for n > 10:

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

IrredundancePolynomial

Entity["Graph",{"Trapezohedron",n}]["IrredundancePolynomial"]

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

FindLinearRecurrence[DeleteMissing@poly]//Head

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

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

IrredundantSetCount

Entity["Graph",{"Trapezohedron",n}]["IrredundantSetCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

IsolatedPointCount

Entity["Graph",{"Trapezohedron",n}]["IsolatedPointCount"]

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

KatzCentralities

Entity["Graph",{"Trapezohedron",n}]["KatzCentralities"]

seq=Table[GraphData[{"Trapezohedron",n},"KatzCentralities"],{n,3,20}]/.f_Function:>f[x,y]

Union/@seq

KirchhoffIndex

Entity["Graph",{"Trapezohedron",n}]["KirchhoffIndex"]

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

(seq=Table[KirchhoffIndex[TrapezohedralGraph[n]],{n,3,150}]);//Timing

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

Do[Print[{k,FindSequenceFunction[Drop[seq,k],n-2-k]//Head//Timing}],{k,0,3}]

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

KirchhoffSumIndex

Entity["Graph",{"Trapezohedron",n}][""]

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

(seq=Table[KirchhoffSumIndex[TrapezohedralGraph[n]],{n,3,150}]);//Timing

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

Do[Print[{k,FindSequenceFunction[Drop[seq,k],n-2-k]//Head//Timing}],{k,0,3}]

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

LaplacianPolynomial

Entity["Graph",{"Trapezohedron",n}]["LaplacianPolynomial"][x]

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

<<MathWorld`Graphs`

(poly=Table[Factor@LaplacianPolynomial[TrapezohedralGraph[n],x],{n,k0=3,kmax=30}])//Timing

coef=Factor/@FindLinearRecurrence[poly]

Length[coef]

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

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

poly2=Table[(((2^(-n)) (1+n-x) x (n (-4+x)-(-5+x) x) (-(2^(1+n))+(((7+(x^2)+3 (Sqrt[5-6 x+(x^2)])-x (6+(Sqrt[5-6 x+(x^2)]))))^n)+(((7-3 (Sqrt[(-5+x) (-1+x)])+x (-6+x+(Sqrt[5-6 x+(x^2)]))))^n)))/((-5+x) (-1+x))),{n,3,30}]//Expand//Together;//Timing

poly-poly2//Expand

(((2^(-n)) (1+n-x) x (n (-4+x)-(-5+x) x) (-(2^(1+n))+(((7+(x^2)+3 (Sqrt[5-6 x+(x^2)])-x (6+(Sqrt[5-6 x+(x^2)]))))^n)+(((7-3 (Sqrt[(-5+x) (-1+x)])+x (-6+x+(Sqrt[5-6 x+(x^2)]))))^n)))/((-5+x) (-1+x)))/.{(7+(x^2)+3 (Sqrt[5-6 x+(x^2)])-x (6+(Sqrt[5-6 x+(x^2)])))->a,(7-3 (Sqrt[(-5+x) (-1+x)])+x (-6+x+(Sqrt[5-6 x+(x^2)])))->b}//FullSimplify

Factor[(n (-4+x)-(-5+x) x)]

poly2=Table[With[{a=(7+(x^2)+3 (Sqrt[5-6 x+(x^2)])-x (6+(Sqrt[5-6 x+(x^2)]))),b=(7-3 (Sqrt[(-5+x) (-1+x)])+x (-6+x+(Sqrt[5-6 x+(x^2)])))},((((a^n)+(b^n)-(2^(n+1))) (x-n-1) x (x^2-(n+5)x+4n))/((x-5) (x-1)(2^n)))],{n,3,30}]//Expand//Together;//Timing

poly-poly2//Expand

Table[(((a^n)+(b^n))/(2^n))/.{
a->(7+(x^2)+3 (Sqrt[5-6 x+(x^2)])-x (6+(Sqrt[5-6 x+(x^2)]))),
b->(7-3 (Sqrt[(-5+x) (-1+x)])+x (-6+x+(Sqrt[5-6 x+(x^2)])))},{n,5}]//Expand//Together//Expand

A110168

CoefficientList[%,x]

LeafCount

Entity["Graph",{"Trapezohedron",n}]["LeafCount"]

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

Likelihood

Entity["Graph",{"Trapezohedron",n}]["Likelihood"]

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

LinearArboricity

Entity["Graph",{"Trapezohedron",n}]["LinearArboricity"]

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

LocalClusteringCoefficients

Entity["Graph",{"Trapezohedron",n}]["LocalClusteringCoefficients"]

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

Tally/@seq

Table[ConstantArray[0,2(n+1)],{n,3,20}]===seq

LongestCycleCount

Entity["Graph",{"Trapezohedron",n}]["LongestCycleCount"]

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

== HamiltonianCycleCount

LongestPathCount

Entity["Graph",{"Trapezohedron",n}]["LongestPathCount"]

Inferred for n > 17:

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

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

TraditionalForm[%]

LongestPathLength

Entity["Graph",{"Trapezohedron",n}]["LongestPathLength"]

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

FindSequenceFunction[seq,n-2]//Factor

LovaszNumber

Entity["Graph",{"Trapezohedron",n}]["LovaszNumber"]

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

LowerIndependenceNumber

Entity["Graph",{"Trapezohedron",n}]["LowerIndependenceNumber"]

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

LowerMatchingNumber

Entity["Graph",{"Trapezohedron",n}]["LowerMatchingNumber"]

Inferred for n > 17:

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

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

LucasCube

Entity["Graph",{"Trapezohedron",n}]["LucasCube"]

seq=Table[GraphData[{"Trapezohedron",n},"LucasCube"],{n,3,20}]

MatchingGeneratingPolynomial

Entity["Graph",{"Trapezohedron",n}]["MatchingGeneratingPolynomial"]

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

coef=Factor/@FindLinearRecurrence[poly]

Length[coef]

LinearRecurrence[coef,Take[poly,6],{-1,4}]

LinearRecurrence[{3 (1+2 x),-3 (1+4 x+5 x^2),(1+2 x) (1+4 x+10 x^2),-3 x^2 (1+4 x+5 x^2),3 x^4 (1+2 x),-x^6},{1+4 x+x^2,1+8 x+14 x^2+4 x^3,(1+4 x+x^2) (1+8 x+9 x^2),1+16 x+84 x^2+168 x^3+114 x^4+16 x^5,1+20 x+140 x^2+420 x^3+540 x^4+252 x^5+25 x^6,1+24 x+210 x^2+844 x^3+1641 x^4+1464 x^5+494 x^6+36 x^7},3]//Column

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

expr=();

FullSimplify[expr/.{(1+2 x-(Sqrt[1+4 x]))->a,(1+2 x+(Sqrt[1+4 x]))->b}]//Timing

FullSimplify@Table[{(((1+2 x-(Sqrt[1+4 x])))^k)->(a^k),(((1+2 x+(Sqrt[1+4 x])))^k)->(b^k)},{k,2,3}]

Table[Expand[(((1+2 x-(Sqrt[1+4 x])))^k)+(((1+2 x+(Sqrt[1+4 x])))^k)]//Factor,{k,20}]

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

MatchingNumber

Entity["Graph",{"Trapezohedron",n}]["MatchingNumber"]

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

MatchingPolynomial

Entity["Graph",{"Trapezohedron",n}]["MatchingPolynomial"]

(poly=Table[GraphData[{"Trapezohedron",n},"MatchingPolynomial"][x],{n,k0=3,20}])//Column

coef=Factor/@FindLinearRecurrence[poly]

coef={3 (-2+(x^2)),-3 (5-4 (x^2)+(x^4)),(-2+(x^2)) (10-4 (x^2)+(x^4)),-3 (5-4 (x^2)+(x^4)),3 (-2+(x^2)),-1};

Length[coef]

LinearRecurrence[coef,Take[poly,6],{-1,4}]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

recurrence=p[n,x]==-p[-6+n,x]+3 (-2+(x^2)) p[-5+n,x]-3 (5-4 (x^2)+(x^4)) p[-4+n,x]+(-2+(x^2)) (10-4 (x^2)+(x^4)) p[-3+n,x]-3 (5-4 (x^2)+(x^4)) p[-2+n,x]+3 (-2+(x^2)) p[-1+n,x];

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n]]

FullSimplify@Table[{(((1+2 x-(Sqrt[1+4 x])))^k)->(a^k),(((1+2 x+(Sqrt[1+4 x])))^k)->(b^k)},{k,2,3}]

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

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

FindGeneratingFunction[poly,z]

MaximalCliqueCount

Entity["Graph",{"Trapezohedron",n}]["MaximalCliqueCount"]

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

FindSequenceFunction[seq,n-2]//Factor

MaximalCliquePolynomial

Entity["Graph",{"Trapezohedron",n}]["MaximalCliquePolynomial"][x]

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

FindSequenceFunction[poly,n-2]//Factor

MaximalIndependencePolynomial

Entity["Graph",{"Trapezohedron",n}]["MaximalIndependencePolynomial"]

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

Length[coef]

LinearRecurrence[coef,Take[poly,5],{-1,3}]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n]

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

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

Table[(-((x-3 Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]) (x-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]) ((Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2])^n) (Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3]))+(x-3 Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]) (x-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]) ((Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1])^n) (Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3])+(Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]) (x-3 Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3]) (x-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3]) ((Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3])^n))/((Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]) (Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3]) (Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3])),{n,10}]//FullSimplify//Expand

CoefficientList[%,x]

Roots[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&[z]==0,x]

Table[((Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]) (Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,1]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3]) (Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,2]-Root[-(x^2)+(x^2) #1-2 x ((#1)^2)+((#1)^3)&,3])),{n,10}]//FullSimplify//Expand

poly2=Table[GraphData[{"Trapezohedron",n},"MaximalIndependencePolynomial"]-(x^2)+2 (-1+x) (x^n),{n,k0=3,20}]/.f_Function:>f[x]

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly2]

Length[coef]

LinearRecurrence[coef,Take[poly2,4],{-1,2}]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n]//FullSimplify

gf=(x^k0)FindGeneratingFunction[poly2,z]

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

MaximalIndependentEdgeSetCount

Entity["Graph",{"Trapezohedron",n}]["MaximalIndependentEdgeSetCount"]

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

Do[Print[{n,Length[FindAllMaximalIndependentEdgeSets[TrapezohedralGraph[n]]]//Timing}],{n,3,30}]

seq={17,50,132,326,772,1762,3899,8422,17844,37202,76507,155514,312947,624258,1235681,2429282,4746772,9224402,17837276,34337470,65830947,125737442};

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

FindSequenceFunction[seq,n-2]

coef=FindLinearRecurrence[seq]

coef={7,-21,38,-50,51,-40,25,-12,4,-1};

Length[coef]

LinearRecurrence[coef,Take[seq,10],{-1,8}]

recurrence=ToPolynomialRecurrence[p,Null,n,coef]/.Null->Sequence@@{}

recurrence=(p[n]==-p[-10+n]+4 p[-9+n]-12 p[-8+n]+25 p[-7+n]-40 p[-6+n]+51 p[-5+n]-50 p[-4+n]+38 p[-3+n]-21 p[-2+n]+7 p[-1+n]);

RSolve[{recurrence,Sequence@@Table[p[i+k0-1]==seq[[i]],{i,Length[coef]}]},p[n],n]

MaximalIndependentVertexSetCount

Entity["Graph",{"Trapezohedron",n}]["MaximalIndependentVertexSetCount"]

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

FindSequenceFunction[DeleteMissing@seq,n-2]

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

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

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

MaximalIrredundancePolynomial

Entity["Graph",{"Trapezohedron",n}]["MaximalIrredundancePolynomial"]

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

FindLinearRecurrence[DeleteMissing@poly]//Head

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

MaximalIrredundantSetCount

Entity["Graph",{"Trapezohedron",n}]["MaximalIrredundantSetCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

MaximalMatchingGeneratingPolynomial

Entity["Graph",{"Trapezohedron",n}]["MaximalMatchingGeneratingPolynomial"]

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

FindLinearRecurrence[Rest@DeleteMissing@poly]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

MaximumCliqueCount

Entity["Graph",{"Trapezohedron",n}]["MaximumCliqueCount"]

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

FindSequenceFunction[seq,n-2]//Factor

MaximumIndependentEdgeSetCount

Entity["Graph",{"Trapezohedron",n}]["MaximumIndependentEdgeSetCount"]

Inferred for n > 17:

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

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

MaximumIndependentVertexSetCount

Entity["Graph",{"Trapezohedron",n}]["MaximumIndependentVertexSetCount"]

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

MaximumIrredundantSetCount

Entity["Graph",{"Trapezohedron",n}]["MaximumIrredundantSetCount"]

Inferred for n > 11:

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

MaximumLeafNumber

Entity["Graph",{"Trapezohedron",n}]["MaximumLeafNumber"]

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

FindSequenceFunction[seq,n-2]//Factor

MaximumVertexDegree

Entity["Graph",{"Trapezohedron",n}]["MaximumVertexDegree"]

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

MeanClusteringCoefficient

Entity["Graph",{"Trapezohedron",n}]["MeanClusteringCoefficient"]

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

MeanDistance

Entity["Graph",{"Trapezohedron",n}]["MeanDistance"]

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

FindSequenceFunction[seq,n-2]//Factor

Median

Entity["Graph",{"Trapezohedron",n}]["Median"]

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

MetricDimension

Entity["Graph",{"Trapezohedron",n}]["MetricDimension"]

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

Meyniel

Entity["Graph",{"Trapezohedron",n}]["Meyniel"]

seq=Table[GraphData[{"Trapezohedron",n},"Meyniel"],{n,3,20}]

MinimalConnectedDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["MinimalConnectedDominatingSetCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

MinimalConnectedDominationPolynomial

Entity["Graph",{"Trapezohedron",n}]["MinimalConnectedDominationPolynomial"]

(seq=Table[GraphData[{"Trapezohedron",n},"MinimalConnectedDominationPolynomial"],{n,3,20}]/.f_Function:>f[x])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

MinimalDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["MinimalDominatingSetCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

MinimalDominationPolynomial

Entity["Graph",{"Trapezohedron",n}]["MinimalDominationPolynomial"]

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

coef=Factor/@FindLinearRecurrence[Rest@DeleteMissing@poly]

MinimalEdgeCoverCount

Entity["Graph",{"Trapezohedron",n}]["MinimalEdgeCoverCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

MinimalEdgeCoverPolynomial

Entity["Graph",{"Trapezohedron",n}]["MinimalEdgeCoverPolynomial"]

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

MinimalEdgeCutCount

Entity["Graph",{"Trapezohedron",n}]["MinimalEdgeCutCount"]

seq=Table[GraphData[{"Trapezohedron",n},"MinimalEdgeCutCount"],{n,3,20}]

MinimalEdgeCutPolynomial

Entity["Graph",{"Trapezohedron",n}]["MinimalEdgeCutPolynomial"]

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

MinimalTotalDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["MinimalTotalDominatingSetCount"]

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

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

Sqrt[DeleteMissing@seq]

-Subtract@@@Partition[%,2,1]

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

MinimalTotalDominationPolynomial

Entity["Graph",{"Trapezohedron",n}]["MinimalTotalDominationPolynomial"]

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

MinimalVertexCoverCount

Entity["Graph",{"Trapezohedron",n}]["MinimalVertexCoverCount"]

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

FindSequenceFunction[seq,n-2]//FullSimplify

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

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

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

MinimalVertexCoverPolynomial

Entity["Graph",{"Trapezohedron",n}]["MinimalVertexCoverPolynomial"]

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

Length[coef]

LinearRecurrence[coef,Take[poly,5],{-1,3}]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n]

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

FullSimplify[SeriesCoefficient[gf,{z,0,n}],n∈Integers]

MinimalVertexCutCount

Entity["Graph",{"Trapezohedron",n}]["MinimalVertexCutCount"]

seq=Table[GraphData[{"Trapezohedron",n},"MinimalVertexCutCount"],{n,3,20}]

Do[Print[{k,FindSequenceFunction[DeleteMissing@Drop[seq,k],n-2-k]//Head//Timing}],{k,0,3}]

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

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

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

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

MinimalVertexCutPolynomial

Entity["Graph",{"Trapezohedron",n}]["MinimalVertexCutPolynomial"]

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

coef=FindLinearRecurrence[DeleteMissing@poly]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

MinimumConnectedDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["MinimumConnectedDominatingSetCount"]

Inferred for n > 11:

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

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

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

MinimumCoveringsByMaximalCliquesCount

Entity["Graph",{"Trapezohedron",n}]["MinimumCoveringsByMaximalCliquesCount"]

Inferred for n > 7:

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

FindSequenceFunction[seq,n-2]//Factor

MinimumCyclicEdgeCutCount

Entity["Graph",{"Trapezohedron",n}]["MinimumCyclicEdgeCutCount"]

Inferred for n > 8:

seq=Table[GraphData[{"Trapezohedron",n},"MinimumCyclicEdgeCutCount"],{n,3,20}]

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

MinimumDistinguishingLabelingCount

Entity["Graph",{"Trapezohedron",n}]["MinimumDistinguishingLabelingCount"]

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

MinimumDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["MinimumDominatingSetCount"]

Inferred for n > 13:

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

MinimumEdgeCoverCount

Entity["Graph",{"Trapezohedron",n}]["MinimumEdgeCoverCount"]

Inferred for n > 6:

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

FindSequenceFunction[seq,n-2]//Factor

MinimumEdgeCutCount

Entity["Graph",{"Trapezohedron",n}]["MinimumEdgeCutCount"]

Inferred for n > 19:

seq=Table[GraphData[{"Trapezohedron",n},"MinimumEdgeCutCount"],{n,3,20}]

MinimumLeafNumber

Entity["Graph",{"Trapezohedron",n}]["MinimumLeafNumber"]

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

MinimumPathCoveringCount

Entity["Graph",{"Trapezohedron",n}]["MinimumPathCoveringCount"]

Inferred for n > 17:

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

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

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

Table[2 n (6-7 n+3 (n^2)),{n,3,20}]

MinimumTotalDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["MinimumTotalDominatingSetCount"]

Inferred for n > 12:

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

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

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

MinimumVertexCoverCount

Entity["Graph",{"Trapezohedron",n}]["MinimumVertexCoverCount"]

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

MinimumVertexCutCount

Entity["Graph",{"Trapezohedron",n}]["MinimumVertexCutCount"]

Inferred for n > 18:

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

MinimumVertexDegree

Entity["Graph",{"Trapezohedron",n}]["MinimumVertexDegree"]

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

MinorCount

Entity["Graph",{"Trapezohedron",n}]["MinorCount"]

seq=Table[GraphData[{"Trapezohedron",n},"MinorCount"],{n,3,20}]

MolecularTopologicalIndex

Entity["Graph",{"Trapezohedron",n}]["MolecularTopologicalIndex"]

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

FindSequenceFunction[seq,n-2]//FullSimplify

Nonhamiltonian

Entity["Graph",{"Trapezohedron",n}]["Nonhamiltonian"]

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

NoPerfectMatching

Entity["Graph",{"Trapezohedron",n}]["NoPerfectMatching"]

Table[GraphData[{"Trapezohedron",n},"NoPerfectMatching"],{n,3,20}]

Nut

Entity["Graph",{"Trapezohedron",n}]["Nut"]

Table[GraphData[{"Trapezohedron",n},"Nut"],{n,3,20}]

OddChordlessCycleCount

Entity["Graph",{"Trapezohedron",n}]["OddChordlessCycleCount"]

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

OddChordlessCyclePolynomial

Entity["Graph",{"Trapezohedron",n}]["OddChordlessCyclePolynomial"][x]

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

Outerplanar

Entity["Graph",{"Trapezohedron",n}]["Outerplanar"]

Table[GraphData[{"Trapezohedron",n},"Outerplanar"],{n,3,20}]

PageRankCentralities

Entity["Graph",{"Trapezohedron",n}]["PageRankCentralities"]

Entity["Graph",{"Trapezohedron",n}]["PageRankCentralities"]

PathCount

Entity["Graph",{"Trapezohedron",n}]["PathCount"]

Infer for n == 20:

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

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

Table[(1/30) n (-150+564 n-305 (n^2)+230 (n^3)-55 (n^4)+16 (n^5)),{n,3,20}]

(1/30) n (-150+564 n-305 (n^2)+230 (n^3)-55 (n^4)+16 (n^5))//TraditionalForm

PathCoveringNumber

Entity["Graph",{"Trapezohedron",n}]["PathCoveringNumber"]

seq=Table[GraphData[{"Trapezohedron",n},"PathCoveringNumber"],{n,3,20}]

PathPolynomial

Entity["Graph",{"Trapezohedron",n}]["PathPolynomial"]

Inferred for n > 19:

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

Length[coef]

LinearRecurrence[coef,Take[poly,8],{-1,6}]

Factor/@%

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]//Factor

poly2=Table[-(1/((((-1+x))^5) (((1+x))^4)))n (4 x+(x^2)+n (x^2)-17 (x^3)+3 n (x^3)-20 (x^4)+4 n (x^4)+14 (x^5)-8 n (x^5)+2 (n^2) (x^5)+58 (x^6)-42 n (x^6)+6 (n^2) (x^6)+60 (x^7)-38 n (x^7)+2 (n^2) (x^7)+56 (x^8)+16 n (x^8)-10 (n^2) (x^8)+22 (x^9)+44 n (x^9)-10 (n^2) (x^9)+13 (x^10)+21 n (x^10)+2 (n^2) (x^10)+(x^11)-n (x^11)+6 (n^2) (x^11)+2 (n^2) (x^12)-2 (x^(2 n))-4 (x^(1+2 n))+8 (x^(2+2 n))+6 n (x^(2+2 n))+18 (x^(3+2 n))+6 n (x^(3+2 n))+4 (x^(4+2 n))-14 n (x^(4+2 n))-4 (n^2) (x^(4+2 n))-18 (x^(5+2 n))-28 n (x^(5+2 n))-6 (n^2) (x^(5+2 n))-44 (x^(6+2 n))-32 n (x^(6+2 n))+2 (n^2) (x^(6+2 n))-54 (x^(7+2 n))-2 n (x^(7+2 n))+12 (n^2) (x^(7+2 n))-62 (x^(8+2 n))+26 n (x^(8+2 n))+8 (n^2) (x^(8+2 n))-26 (x^(9+2 n))+24 n (x^(9+2 n))-6 (n^2) (x^(9+2 n))-12 (x^(10+2 n))+14 n (x^(10+2 n))-6 (n^2) (x^(10+2 n))),{n,3,20}]//Together//Expand;

poly-poly2

expr= (4 x+(x^2)+n (x^2)-17 (x^3)+3 n (x^3)-20 (x^4)+4 n (x^4)+14 (x^5)-8 n (x^5)+2 (n^2) (x^5)+58 (x^6)-42 n (x^6)+6 (n^2) (x^6)+60 (x^7)-38 n (x^7)+2 (n^2) (x^7)+56 (x^8)+16 n (x^8)-10 (n^2) (x^8)+22 (x^9)+44 n (x^9)-10 (n^2) (x^9)+13 (x^10)+21 n (x^10)+2 (n^2) (x^10)+(x^11)-n (x^11)+6 (n^2) (x^11)+2 (n^2) (x^12)-2 (x^(2 n))-4 (x^(1+2 n))+8 (x^(2+2 n))+6 n (x^(2+2 n))+18 (x^(3+2 n))+6 n (x^(3+2 n))+4 (x^(4+2 n))-14 n (x^(4+2 n))-4 (n^2) (x^(4+2 n))-18 (x^(5+2 n))-28 n (x^(5+2 n))-6 (n^2) (x^(5+2 n))-44 (x^(6+2 n))-32 n (x^(6+2 n))+2 (n^2) (x^(6+2 n))-54 (x^(7+2 n))-2 n (x^(7+2 n))+12 (n^2) (x^(7+2 n))-62 (x^(8+2 n))+26 n (x^(8+2 n))+8 (n^2) (x^(8+2 n))-26 (x^(9+2 n))+24 n (x^(9+2 n))-6 (n^2) (x^(9+2 n))-12 (x^(10+2 n))+14 n (x^(10+2 n))-6 (n^2) (x^(10+2 n)));

Expand[expr]//Together

Collect[expr,{n},Factor]

ByteCount/@{(4 x+(x^2)+n (x^2)-17 (x^3)+3 n (x^3)-20 (x^4)+4 n (x^4)+14 (x^5)-8 n (x^5)+2 (n^2) (x^5)+58 (x^6)-42 n (x^6)+6 (n^2) (x^6)+60 (x^7)-38 n (x^7)+2 (n^2) (x^7)+56 (x^8)+16 n (x^8)-10 (n^2) (x^8)+22 (x^9)+44 n (x^9)-10 (n^2) (x^9)+13 (x^10)+21 n (x^10)+2 (n^2) (x^10)+(x^11)-n (x^11)+6 (n^2) (x^11)+2 (n^2) (x^12)-2 (x^(2 n))-4 (x^(1+2 n))+8 (x^(2+2 n))+6 n (x^(2+2 n))+18 (x^(3+2 n))+6 n (x^(3+2 n))+4 (x^(4+2 n))-14 n (x^(4+2 n))-4 (n^2) (x^(4+2 n))-18 (x^(5+2 n))-28 n (x^(5+2 n))-6 (n^2) (x^(5+2 n))-44 (x^(6+2 n))-32 n (x^(6+2 n))+2 (n^2) (x^(6+2 n))-54 (x^(7+2 n))-2 n (x^(7+2 n))+12 (n^2) (x^(7+2 n))-62 (x^(8+2 n))+26 n (x^(8+2 n))+8 (n^2) (x^(8+2 n))-26 (x^(9+2 n))+24 n (x^(9+2 n))-6 (n^2) (x^(9+2 n))-12 (x^(10+2 n))+14 n (x^(10+2 n))-6 (n^2) (x^(10+2 n))),4 x+(x^2)-17 (x^3)-20 (x^4)+14 (x^5)+58 (x^6)+60 (x^7)+56 (x^8)+22 (x^9)+13 (x^10)+(x^11)-2 (x^(2 n))-4 (x^(1+2 n))+8 (x^(2+2 n))+18 (x^(3+2 n))+4 (x^(4+2 n))-18 (x^(5+2 n))-44 (x^(6+2 n))-54 (x^(7+2 n))-62 (x^(8+2 n))-26 (x^(9+2 n))-12 (x^(10+2 n))-2 (n^2) (((-1+x))^2) (x^4) (((1+x))^2) (-x-3 (x^2)-3 (x^3)-(x^4)+2 (x^(2 n))+3 (x^(1+2 n))+3 (x^(2+2 n)))-n (-1+x) (x^2) (1+x) (1+3 x+5 (x^2)-5 (x^3)-37 (x^4)-43 (x^5)-21 (x^6)+(x^7)+6 (x^(2 n))+6 (x^(1+2 n))-8 (x^(2+2 n))-22 (x^(3+2 n))-40 (x^(4+2 n))-24 (x^(5+2 n))-14 (x^(6+2 n)))}

Factor[4 x+(x^2)-17 (x^3)-20 (x^4)+14 (x^5)+58 (x^6)+60 (x^7)+56 (x^8)+22 (x^9)+13 (x^10)+(x^11)-2 (x^(2 n))-4 (x^(1+2 n))+8 (x^(2+2 n))+18 (x^(3+2 n))+4 (x^(4+2 n))-18 (x^(5+2 n))-44 (x^(6+2 n))-54 (x^(7+2 n))-62 (x^(8+2 n))-26 (x^(9+2 n))-12 (x^(10+2 n))]

(gf=(z^3)FindGeneratingFunction[poly,z])//Timing

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

PebblingNumber

Entity["Graph",{"Trapezohedron",n}]["PebblingNumber"]

seq=Table[GraphData[{"Trapezohedron",n},"PebblingNumber"],{n,3,20}]

Entity["Graph",{"Trapezohedron",n}][""]

Pell

Entity["Graph",{"Trapezohedron",n}]["Pell"]

seq=Table[GraphData[{"Trapezohedron",n},"Pell"],{n,3,20}]

PentagonCount

Entity["Graph",{"Trapezohedron",n}]["PentagonCount"]

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

Perfect

Entity["Graph",{"Trapezohedron",n}]["Perfect"]

Table[GraphData[{"Trapezohedron",n},"Perfect"],{n,3,20}]

PerfectMatching

Entity["Graph",{"Trapezohedron",n}]["PerfectMatching"]

Table[GraphData[{"Trapezohedron",n},"PerfectMatching"],{n,3,20}]

Periphery

Entity["Graph",{"Trapezohedron",n}]["Periphery"]

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

Table[Range[2(n+1)],{n,3,20}]===seq

Planar

Entity["Graph",{"Trapezohedron",n}]["Planar"]

Table[GraphData[{"Trapezohedron",n},"Planar"],{n,3,20}]

Polyhedral

Entity["Graph",{"Trapezohedron",n}]["Polyhedral"]

Table[GraphData[{"Trapezohedron",n},"Polyhedral"],{n,3,20}]

Polyhedron

Entity["Graph",{"Trapezohedron",n}]["Polyhedron"]

Table[Graphics3D[{FaceForm[Green,Red],GraphData[{"Trapezohedron",n},"Polyhedron"]}],{n,3,20}]

ProjectivePlaneCrossingNumber

Entity["Graph",{"Trapezohedron",n}]["ProjectivePlaneCrossingNumber"]

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

Pseudoarboricity

Entity["Graph",{"Trapezohedron",n}]["Pseudoarboricity"]

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

Ptolemaic

Entity["Graph",{"Trapezohedron",n}]["Ptolemaic"]

Table[GraphData[{"Trapezohedron",n},"Ptolemaic"],{n,3,20}]

QChromaticPolynomial

Entity["Graph",{"Trapezohedron",n}]["QChromaticPolynomial"]

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

RadialityCentralities

Entity["Graph",{"Trapezohedron",n}]["RadialityCentralities"]

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

Tally/@seq//Column

RadioLabelingCount

Entity["Graph",{"Trapezohedron",n}]["RadioLabelingCount"]

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

RadioNumber

Entity["Graph",{"Trapezohedron",n}]["RadioNumber"]

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

Radius

Entity["Graph",{"Trapezohedron",n}]["Radius"]

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

Rank

Entity["Graph",{"Trapezohedron",n}]["Rank"]

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

FindSequenceFunction[seq,n-2]//Factor

RankPolynomial

Entity["Graph",{"Trapezohedron",n}]["RankPolynomial"]

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

coef=Factor/@FindLinearRecurrence[poly]

RectilinearCrossingNumber

Entity["Graph",{"Trapezohedron",n}]["RectilinearCrossingNumber"]

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

Regular

Entity["Graph",{"Trapezohedron",n}]["Regular"]

Table[GraphData[{"Trapezohedron",n},"Regular"],{n,3,20}]

RegularParameters

Entity["Graph",{"Trapezohedron",n}]["RegularParameters"]

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

ReliabilityPolynomial

Entity["Graph",{"Trapezohedron",n}]["ReliabilityPolynomial"]

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

coef=Factor/@FindLinearRecurrence[poly]

Length[coef]

LinearRecurrence[coef,Take[poly,6],{-1,4}]

ResistanceMatrix

Entity["Graph",{"Trapezohedron",n}]["ResistanceMatrix"]

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

ScrambleNumber

Entity["Graph",{"Trapezohedron",n}]["ScrambleNumber"]

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

ShannonCapacity

Entity["Graph",{"Trapezohedron",n}]["ShannonCapacity"]

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

SigmaPolynomial

Entity["Graph",{"Trapezohedron",n}]["SigmaPolynomial"]

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

Singlecross

Entity["Graph",{"Trapezohedron",n}]["Singlecross"]

Table[GraphData[{"Trapezohedron",n},"Singlecross"],{n,3,20}]

Skewness

Entity["Graph",{"Trapezohedron",n}]["Skewness"]

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

SpanningTreeCount

Entity["Graph",{"Trapezohedron",n}]["SpanningTreeCount"]

A193127

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

FindSequenceFunction[seq,n-2]//FullSimplify

Table[2 n (LucasL[4 n]-2)/5,{n,20}]

SpectralRadius

Entity["Graph",{"Trapezohedron",n}]["SpectralRadius"]

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

Table[1+Sqrt[n+1],{n,3,20}]

SquareCount

Entity["Graph",{"Trapezohedron",n}]["SquareCount"]

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

FindSequenceFunction[seq,n-2]

SquareFree

Entity["Graph",{"Trapezohedron",n}]["SquareFree"]

Table[GraphData[{"Trapezohedron",n},"SquareFree"],{n,3,20}]

StabilityIndex

Entity["Graph",{"Trapezohedron",n}]["StabilityIndex"]

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

(seq=Table[StabilityIndex[TrapezohedralGraph[n]],{n,3,30}])//Timing

coef=FindLinearRecurrence[seq]

Length[coef]

FindSequenceFunction[seq,n-2]

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

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

Table[(1/5) (-2 (((-1))^n) (n^2)-(2^(1+n)) (((-7-3 (Sqrt[5])))^n) (((3+(Sqrt[5])))^(-2 n)) (5+2 n)+((((2/(3+(Sqrt[5])))))^n) (5+n (2+n))+((((1/2) (3+(Sqrt[5]))))^n) (5+n (2+n))),{n,5}]//ExpandAll//Together

((2(3-(Sqrt[5])))/(Expand[(3+(Sqrt[5]))(3-(Sqrt[5]))]))

Table[(1/5) (-2 (((-1))^n) (n^2)-(2^(1+n)) (((-7-3 (Sqrt[5])))^n) (((3+(Sqrt[5])))^(-2 n)) (5+2 n)+((((1/2) (3-(Sqrt[5]))))^n) (5+n (2+n))+((((1/2) (3+(Sqrt[5]))))^n) (5+n (2+n))),{n,5}]//ExpandAll//Together

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

Table[LucasL[2n],{n,5}]

Table[(1/5) (-2 (((-1))^n) (n^2)-(2^(1+n)) (((-7-3 (Sqrt[5])))^n) (((3+(Sqrt[5])))^(-2 n)) (5+2 n)+ (5+n (2+n))LucasL[2n]),{n,5}]//ExpandAll//Together

Table[(((-7-3 (Sqrt[5])))^n) (((3+(Sqrt[5])))^(-2 n)),{n,10}]//ExpandAll//Together

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

Table[(1/5) (-2 (((-1))^n) (n^2)-(2^(1+n)) ((((-1))^n)/(2^n)) (5+2 n)+ (5+n (2+n))LucasL[2n]),{n,5}]//ExpandAll//Together

FullSimplify[(1/5) (-2 (((-1))^n) (n^2)-(2^(1+n)) ((((-1))^n)/(2^n)) (5+2 n)+ (5+n (2+n))LucasL[2n]),]

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

Factor[(n^2+2 n+5)]

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

StarArboricity

Entity["Graph",{"Trapezohedron",n}]["StarArboricity"]

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

StatusCentralities

Entity["Graph",{"Trapezohedron",n}]["StatusCentralities|"]

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

Strength

Entity["Graph",{"Trapezohedron",n}]["Strength"]

Inferred for n > 6:

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

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

StronglyPerfect

Entity["Graph",{"Trapezohedron",n}]["StronglyPerfect"]

Table[GraphData[{"Trapezohedron",n},"StronglyPerfect"],{n,3,20}]

StronglyRegular

Entity["Graph",{"Trapezohedron",n}]["StronglyRegular"]

Table[GraphData[{"Trapezohedron",n},"StronglyRegular"],{n,3,20}]

Symmetric

Entity["Graph",{"Trapezohedron",n}]["Symmetric"]

Table[GraphData[{"Trapezohedron",n},"Symmetric"],{n,3,20}]

SymmetricallyDistinctFaceCount

Entity["Graph",{"Trapezohedron",n}]["SymmetricallyDistinctFaceCount"]

seq=Table[GraphData[{"Trapezohedron",n},"SymmetricallyDistinctFaceCount"],{n,3,20}]

SymmetricallyDistinctVertexCount

Entity["Graph",{"Trapezohedron",n}]["SymmetricallyDistinctVertexCount"]

seq=Table[GraphData[{"Trapezohedron",n},"SymmetricallyDistinctVertexCount"],{n,3,20}]

SymmetricallyDistinctVertexPairCount

Entity["Graph",{"Trapezohedron",n}]["SymmetricallyDistinctVertexPairCount"]

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

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

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

SymmetricallyDistinctVertexPairSignature

Entity["Graph",{"Trapezohedron",n}]["SymmetricallyDistinctVertexPairSignature"]

(seq=Table[GraphData[{"Trapezohedron",n},"SymmetricallyDistinctVertexPairSignature"],{n,3,6}])//Column

Thickness

Entity["Graph",{"Trapezohedron",n}]["Thickness"]

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

TopologicalIndex

Entity["Graph",{"Trapezohedron",n}]["TopologicalIndex"]

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

FindSequenceFunction[seq,n-2]//FullSimplify

ToroidalCrossingNumber

Entity["Graph",{"Trapezohedron",n}]["ToroidalCrossingNumber"]

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

TotalDominatingSetCount

Entity["Graph",{"Trapezohedron",n}]["TotalDominatingSetCount"]

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,4}]

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

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

TotalDominationNumber

Entity["Graph",{"Trapezohedron",n}]["TotalDominationNumber"]

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

TotalDominationPolynomial

Entity["Graph",{"Trapezohedron",n}]["TotalDominationPolynomial"]

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

recurrence=ToPolynomialRecurrence[p,x,n,coef]

FullSimplify[RSolve[{recurrence,Sequence@@Table[p[i+k0-1,x]==poly[[i]],{i,Length[coef]}]},p[n,x],n],n∈Integers]

Toughness

Entity["Graph",{"Trapezohedron",n}]["Toughness"]

Inferred for n > 10:

seq=Table[GraphData[{"Trapezohedron",n},"Toughness"],{n,3,20}]

Traceable

Entity["Graph",{"Trapezohedron",n}]["Traceable"]

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

TreeDepth

Entity["Graph",{"Trapezohedron",n}]["TreeDepth"]

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

TreeNumber

Entity["Graph",{"Trapezohedron",n}]["TreeNumber"]

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

Treewidth

Entity["Graph",{"Trapezohedron",n}]["Treewidth"]

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

Triameter

Entity["Graph",{"Trapezohedron",n}]["Triameter"]

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

TriangleCount

Entity["Graph",{"Trapezohedron",n}]["TriangleCount"]

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

TriangleFree

Entity["Graph",{"Trapezohedron",n}]["TriangleFree"]

Table[GraphData[{"Trapezohedron",n},"TriangleFree"],{n,3,20}]

TuttePolynomial

Entity["Graph",{"Trapezohedron",n}]["TuttePolynomial"]

(poly=Table[GraphData[{"Trapezohedron",n},"TuttePolynomial"],{n,3,10}]/.f_Function:>f[x,y])//Column

Unicyclic

Entity["Graph",{"Trapezohedron",n}]["Unicyclic"]

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

UniquelyColorable

Entity["Graph",{"Trapezohedron",n}]["UniquelyColorable"]

Inferred for n > 12:

seq=Table[GraphData[{"Trapezohedron",n},"UniquelyColorable"],{n,3,20}]

UniquelyPancyclic

Entity["Graph",{"Trapezohedron",n}]["UniquelyPancyclic"]

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

UnitDistance

Entity["Graph",{"Trapezohedron",n}]["UnitDistance"]

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

Do[Print[{n,UnitDistanceGraphQ[GraphData[{"Trapezohedron",n}]]//Timing}],{n,3,20}]

UpperDominationNumber

Entity["Graph",{"Trapezohedron",n}]["UpperDominationNumber"]

Inferred for n > 7:

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

UpperIrredundanceNumber

Entity["Graph",{"Trapezohedron",n}]["UpperIrredundanceNumber"]

Inferred for n > 12:

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

VertexConnectivity

Entity["Graph",{"Trapezohedron",n}]["VertexConnectivity"]

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

VertexCount

Entity["Graph",{"Trapezohedron",n}]["VertexCount"]

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

FindSequenceFunction[seq,n-2]

VertexCoverCount

Entity["Graph",{"Trapezohedron",n}]["VertexCoverCount"]

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

FindSequenceFunction[seq,n-2]//FullSimplify

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

Table[1+(2^(n+1))+LucasL[2n],{n,3,20}]

VertexCoverNumber

Entity["Graph",{"Trapezohedron",n}]["VertexCoverNumber"]

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

FindSequenceFunction[seq,n-2]

VertexCoverPolynomial

Entity["Graph",{"Trapezohedron",n}]["VertexCoverPolynomial"]

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

coef=Factor/@FindLinearRecurrence[poly]

Length[coef]

LinearRecurrence[coef,Take[poly,4],{-1,2}]

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]

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

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

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

Table[LucasL[2n,(Sqrt[x])],{n,5}]//Expand

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

FullSimplify[(x^(2 n))+2 x (((x (1+x)))^n)+(x^(n+2)) LucasL[2n,(Sqrt[x])]]

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

VertexCutCount

Entity["Graph",{"Trapezohedron",n}]["VertexCutCount"]

seq=Table[GraphData[{"Trapezohedron",n},"VertexCutCount"],{n,3,20}]

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,2}]

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

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

VertexCutPolynomial

Entity["Graph",{"Trapezohedron",n}]["VertexCutPolynomial"]

(poly=Table[GraphData[{"Trapezohedron",n},"VertexCutPolynomial"],{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]

VertexDegrees

Entity["Graph",{"Trapezohedron",n}]["VertexDegrees"]

(seq=Table[GraphData[{"Trapezohedron",n},"VertexDegrees"],{n,3,20}])//Column

Tally/@seq

Table[Join[ConstantArray[3,2n],{n,n}],{n,3,20}]===seq

VertexTransitive

Entity["Graph",{"Trapezohedron",n}]["VertexTransitive"]

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

WienerIndex

Entity["Graph",{"Trapezohedron",n}]["WienerIndex"]

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

FindSequenceFunction[seq,n-2]//Factor

WienerSumIndex

Entity["Graph",{"Trapezohedron",n}]["WienerSumIndex"]

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

(seq=Table[WienerSumIndex[TrapezohedralGraph[n]],{n,3,70}]);//Timing

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

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing[seq],k],n-2-k]//Head//Timing}],{k,0,2}]

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

Embeddings

{"Trapezohedron", 3}

All

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

3D Polyhedron

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

Graphics3D[GraphData[{"Trapezohedron",3},"Polyhedron"]]

{"Trapezohedron", 4}

All

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

GraphData[{"Trapezohedron",4},"Graph",{"3D","Polyhedron"}]//StyleGraphs

g=PolyhedronGraph[PolyhedronData[{"Trapezohedron",4},"Polyhedron"]]

Graphics3D[GraphData[{"Trapezohedron",4},"Polyhedron"]]

GraphData

GraphPropertyString

GraphDataClassString["Trapezohedron"]

GraphDataString

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

Do[WriteString[file,GraphDataString[
TrapezohedralGraph[n],
"StandardName"->{"Trapezohedron",n},
"Name"->ToString[n]<>"\[Hyphen]trapezohedral graph",
"Information"->"TrapezohedralGraph",
"Classes"->{"Trapezohedron"},
"NotationRules"->{"Trapezohedron"->n},
Debug->True
]],{n,4,4}]

Do[WriteString[file,GraphDataString[
TrapezohedralGraph[n],
"StandardName"->{"Trapezohedron",n},
"Name"->ToString[n]<>"\[Hyphen]trapezohedral graph",
"Information"->"TrapezohedralGraph",
"Classes"->{"Trapezohedron"},
"NotationRules"->{"Trapezohedron"->n},
Debug->True,
TimeConstraint->10
]],{n,5,16}]

Do[WriteString[file,GraphDataString[
TrapezohedralGraph[n],
"StandardName"->{"Trapezohedron",n},
"Name"->ToString[n]<>"\[Hyphen]trapezohedral graph",
"Information"->"TrapezohedralGraph",
"Classes"->{"Trapezohedron"},
"NotationRules"->{"Trapezohedron"->n},
Debug->True,
TimeConstraint->10
]],{n,17,17}]

Do[WriteString[file,GraphDataString[
TrapezohedralGraph[n],
"StandardName"->{"Trapezohedron",n},
"Name"->ToString[n]<>"\[Hyphen]trapezohedral graph",
"Information"->"TrapezohedralGraph",
"Classes"->{"Trapezohedron"},
"NotationRules"->{"Trapezohedron"->n},
Debug->True,
TimeConstraint->5
]],{n,18,20}]