Odd Graph

Author

Eric W. Weisstein
October 26, 2023

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

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

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

Construction

Combinatorica

?OddGraph

Context[OddGraph]

OddGraph[n_Integer]:=MakeGraph[KSubsets[Range[2n-1],n-1],(SameQ[Intersection[#1,#2],{}])&,Type->Undirected]/;(n>1)

ToEntity/@CombinatoricaGraphToV8Graph/@Table[OddGraph[n],{n,2,5}]

Built-in

MyOddGraph[n_Integer]:=Module[{v=Subsets[Range[2n-1],{n-1}],e},
e=Subsets[v,{2}];
IndexGraph[System`Graph[v,UndirectedEdge@@@Pick[e,DisjointQ@@@e]]]
]

ToEntity/@Table[MyOddGraph[n],{n,5}]

GraphData["Odd"]

Graphic

GraphicsRow[Table[Show[GraphData[{"Odd",n}]//StyleGraphs,PlotLabel->Style[Column[{HoldForm[n]==n,Style[GraphData[{"Odd",n},"Name"],Italic]},Alignment->Center],Directive[Black,14,FontFamily->"Times"]]],{n,4}],ImageSize->700,Dividers->All,Alignment->Center]

Notation

odd=DeleteMissing[FirstCase[GraphData[#,"StandardNames"],{"Odd",_}]&/@GraphData[All]]

TextGrid[Sort[{GraphData[#,"V"],GraphData[#,"#"],#,GraphData[#,"Notation"]}&/@odd],Dividers->All]

Embeddings

<<MathWorld`Graphs`

{"Odd", 1} == "SingletonGraph"

GraphData[{"Odd",1},"StandardName"]

{"Odd", 2} == "TriangleGraph"

GraphData[{"Odd",2},"StandardName"]

{"Odd", 3} == "PetersenGraph"

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

{"Odd", 4}

Names

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

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

Primary

GraphData[{"Odd",4}]//StyleGraphs[#,ImageSize->Small]&

All

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

Inexact

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

Embedding types

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

Default embedding

GraphPlot@GraphData[{"Odd",4},"Edges"]

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

RecognizeGraph[g]

Degenerate

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

7-fold rotationally symmetric construction

Boben et al.

GraphData[{"Odd",4},"V"]

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

RecognizeGraph[g]

VertexCount[g]

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

CrossingNumber[GraphData[{"Odd",4}],TimeConstraint->60]//AbsoluteTiming

g=RotateGraph[MinimalCrossingGraph[GraphData[{"Odd",4}],"CrossingNumber"->cn]]

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Halin

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

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

LCF

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

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

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

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

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

LCF compute all

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"Odd",4},".m.gz"]])[[All,2]]]//Timing

DeleteCases[lcf,{_,1}]

LCFGraph@@@DeleteCases[lcf,{_,1}]//StyleGraphs

Tally[LCFNotation[#][[-1]]&/@(gs=NiceLCFGraphs[lcf,2,None])]//Timing

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine/@GraphData[{"Odd",4},"Graph","All"]

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"Odd",4},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

Properties

Acyclic

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

Table[GraphData[{"Odd",n},"Acyclic"],{n,7}]

AdjacencyMatrixCount

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

seq=Table[GraphData[{"Odd",n},"AdjacencyMatrixCount"],{n,5}]

FindSequenceFunction[seq,n]

Table[((Binomial[2 n-1,n-1]!)/(Gamma[2 n])),{n,5}]

FullSimplify[((Binomial[2 n-1,n-1]!)/(Gamma[2 n]))]

FunctionExpand[%]//FullSimplify

Arboricity

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

Table[GraphData[{"Odd",n},"Arboricity"],{n,7}]

ArcTransitive

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

Table[GraphData[{"Odd",n},"ArcTransitive"],{n,7}]

ArcTransitivity

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

Table[GraphData[{"Odd",n},"ArcTransitivity"],{n,7}]

AutomorphismCount

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

seq=Table[GraphData[{"Odd",n},"AutomorphismCount"],{n,7}]

FindSequenceFunction[seq,n]

FullSimplify[%]

BalabanIndex

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

seq=Table[GraphData[{"Odd",n},"BalabanIndex"],{n,7}]

Do[Print[{{"Odd",n},BalabanIndex[OddGraph1[n]]//Timing}],{n,10}]

seq={0,(9/4),(15/7),(2450/1517),(245/191),(960498/875533),(99099/100862),(13250952/14615399),(46930455/55051289)};

Head/@Table[FindSequenceFunction[Drop[seq,k],n-k],{k,0,3}]

FindGeneratingFunction[seq,x]

FindLinearRecurrence[Drop[seq,2]]

Bandwidth

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

Table[GraphData[{"Odd",n},"Bandwidth"],{n,7}]

BridgeCount

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

seq=Table[GraphData[{"Odd",n},"BridgeCount"],{n,7}]

BurningNumber

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

seq=Table[GraphData[{"Odd",n},"BurningNumber"],{n,7}]

GraphData[{"Odd",1},"#"]

Probably n

Do[Print[{n,BurningNumber[OddGraph[n]]//Timing}],{n,5}]

MaxMemoryUsed[]/10^9.GB

ChordlessCycleCount

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

seq=Table[GraphData[{"Odd",n},"ChordlessCycleCount"],{n,7}]

ChromaticInvariant

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

seq=Table[GraphData[{"Odd",n},"ChromaticInvariant"],{n,7}]

ChromaticNumber

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

seq=Table[GraphData[{"Odd",n},"ChromaticNumber"],{n,7}]

Circumference

A001700

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

seq=Table[GraphData[{"Odd",n},"Circumference"],{n,7}]

Classes

Entity["Graph",{"Odd",n}]["Classes"]

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

CliqueCount

A295934

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

seq=Table[GraphData[{"Odd",n},"CliqueCount"],{n,7}]

FindSequenceFunction[seq,n]

FindGeneratingFunction[seq,x]

CliqueCoveringNumber

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

seq=Table[GraphData[{"Odd",n},"CliqueCoveringNumber"],{n,7}]

FindLinearRecurrence[Rest@seq]

FindSequenceFunction[seq,n]//FullSimplify

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

FindGeneratingFunction[seq,x]

CliqueNumber

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

seq=Table[GraphData[{"Odd",n},"CliqueNumber"],{n,7}]

Probably 2

Do[Print[{n,Length[Flatten[FindClique[OddGraph[n]]]]//Timing}],{n,8}]

MaxMemoryUsed[]/10^9.GB

ComplementOddChordlessCycleCount

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

seq=Table[GraphData[{"Odd",n},"ComplementOddChordlessCycleCount"],{n,7}]

ConnectedDominatingSetCount

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

seq=Table[GraphData[{"Odd",n},"ConnectedDominatingSetCount"],{n,7}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedDominationNumber

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

seq=Table[GraphData[{"Odd",n},"ConnectedDominationNumber"],{n,7}]

ConnectedDominationPolynomial

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

(poly=DeleteCases[Factor@Table[GraphData[{"Odd",n},"ConnectedDominationPolynomial"][x],{n,k0=1,kmax=7}],_Missing[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

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

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

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

seq=Table[GraphData[{"Odd",n},"ConnectedInducedSubgraphCount"],{n,7}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

ConnectedInducedSubgraphPolynomial

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

(poly=DeleteCases[Factor@Table[GraphData[{"Odd",n},"ConnectedInducedSubgraphPolynomial"][x],{n,k0=1,kmax=7}],_Missing[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

poly2=Table[XXX,{n,7}]

FullSimplify[poly2-poly]

CrossingNumber

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

seq=Table[GraphData[{"Odd",n},"CrossingNumber"],{n,7}]

CycleCount

A301558

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

seq=Table[GraphData[{"Odd",n},"CycleCount"],{n,7}]

CyclePolynomial

Entity["Graph",{"Odd",n}]["CyclePolynomial"]

(poly=Table[GraphData[{"Odd",n},"CyclePolynomial"]/.f_Function:>f[x],{n,7}])//Column

Cyclic

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

Table[GraphData[{"Odd",n},"Cyclic"],{n,7}]

CyclomaticNumber

Entity["Graph",{"Odd",n}]["CyclomaticNumber"]

seq=Table[GraphData[{"Odd",n},"CyclomaticNumber"],{n,7}]

FindSequenceFunction[seq,2]//FullSimplify

FindGeneratingFunction[Drop[seq,2],x]

FindLinearRecurrence[seq]

DetourIndex

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

seq=Table[GraphData[{"Odd",n},"DetourIndex"],{n,7}]

FindSequenceFunction[Take[seq,{2,-2}],n-1]

FindGeneratingFunction[Most@seq,x]

Diameter

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

seq=Table[GraphData[{"Odd",n},"Diameter"],{n,7}]

DistinguishingNumber

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

seq=Table[GraphData[{"Odd",n},"DistinguishingNumber"],{n,7}]

DomaticNumber

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

Possibly 4 for n >= 4

seq=Table[GraphData[{"Odd",n},"DomaticNumber"],{n,7}]

Table[GraphData[{"Odd",n},"DominatingSetCount"],{n,7}]

Table[GraphData[{"Odd",n},"MinimalDominatingSetCount"],{n,7}]

Table[Floor[Divide@@GraphData[{"Odd",n},{"VertexCount","DominationNumber"}]],{n,7}]

DominatingSetCount

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

seq=Table[GraphData[{"Odd",n},"DominatingSetCount"],{n,7}]

DominationNumber

A296852

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

seq=Table[GraphData[{"Odd",n},"DominationNumber"],{n,7}]

EdgeChromaticNumber

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

seq=Table[GraphData[{"Odd",n},"EdgeChromaticNumber"],{n,7}]

EdgeConnectivity

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

Table[GraphData[{"Odd",n},"EdgeConnectivity"],{n,7}]

EdgeCount

A033876

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

seq=Table[GraphData[{"Odd",n},"M"],{n,7}]

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

FunctionExpand[%]

FindGeneratingFunction[seq,x]

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

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

FunctionExpand[(((-1))^(1+n)) (2^(-3+2 n)) (-1+2 n) Binomial[-(1/2),-1+n]]

FullSimplify[%]

Table[(((((-1))^n) (4^(-1+n)) (Sqrt[π]))/(Gamma[(1/2)-n] Gamma[n])),{n,7}]

Table[n Binomial[2n,n]/4,{n,7}]

EdgeCoverCount

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

seq=Table[GraphData[{"Odd",n},"EdgeCoverCount"],{n,7}]

EdgeCoverNumber

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

seq=Table[GraphData[{"Odd",n},"EdgeCoverNumber"],{n,7}]

FindSequenceFunction[seq,n]

x FindGeneratingFunction[seq,x]

EulerianCycleCount

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

seq=Table[GraphData[{"Odd",n},"EulerianCycleCount"],{n,7}]

FaceCount

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

seq=Table[GraphData[{"Odd",n},"FaceCount"],{n,7}]

FibonacciCube

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

seq=Table[GraphData[{"Odd",n},"FibonacciCube"],{n,7}]

FractionalChromaticNumber

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

seq=Table[GraphData[{"Odd",n},"FractionalChromaticNumber"],{n,7}]

Table[Piecewise[{{1,n==1}},(2 n-1)/(n-1)],{n,7}]

FractionalEdgeChromaticNumber

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

seq=Table[GraphData[{"Odd",n},"FractionalEdgeChromaticNumber"],{n,7}]

Girth

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

seq=Table[GraphData[{"Odd",n},"Girth"],{n,7}]

Hamiltonian

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

Table[GraphData[{"Odd",n},"Hamiltonian"],{n,7}]

HamiltonDecompositionCount

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

seq=Table[GraphData[{"Odd",n},"HamiltonDecompositionCount"],{n,7}]

HamiltonianCycleCount

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

A301557

seq=Table[GraphData[{"Odd",n},"HamiltonianCycleCount"],{n,7}]

HamiltonianNumber

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

Table[GraphData[{"Odd",n},"Hamiltonian"],{n,7}]

seq=Table[GraphData[{"Odd",n},"HamiltonianNumber"],{n,7}]

FindSequenceFunction[seq,n]

Table[Binomial[-1+2 n,-1+n],{n,7}]

GraphData[{"Odd",3},"#"]

HamiltonianPathCount

A301559

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

seq=Table[GraphData[{"Odd",n},"HamiltonianPathCount"],{n,7}]

HamiltonianWalkCount

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

seq=Table[GraphData[{"Odd",n},"HamiltonianWalkCount"],{n,7}]

HararyIndex

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

seq=Table[GraphData[{"Odd",n},"HararyIndex"],{n,7}]

FindSequenceFunction[seq,n]

FindGeneratingFunction[seq,x]

HexagonCount

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

A300850

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

seq=Table[GraphData[{"Odd",n},"HexagonCount"],{n,7}]

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

FindGeneratingFunction[seq,x]

seq=Table[Piecewise[{{0,n==2}},Binomial[2n-1,n-1]n(n-1)^2/12],{n,20}]

FullSimplify[Binomial[2n-1,n-1]n(n-1)^2/12]

FunctionExpand[%]//FullSimplify

Join[{0,0},Table[Binomial[2n-1,n-1]n(n-1)^2/12,{n,3,18}]]

seq=Table[Piecewise[{{0,n==2}},Binomial[2n-1,n-1]n(n-1)^2/12],{n,20}]

seq=Table[Binomial[2n-1,n-1]n(n-1)^2/12,{n,3,300}];

FindLinearRecurrence[seq]//Head//Timing

gf=x FindGeneratingFunction[seq,x]//FullSimplify

Series[-(((x^2) (-1+(Sqrt[1-4 x])-2 x (3+6 (Sqrt[1-4 x])+8 (Sqrt[1-4 x]) x (-3+4 x))))/(2 (((1-4 x))^(7/2)))),{x,0,20}]

Expand[-(((x^2) (-1+(Sqrt[1-4 x])-2 x (3+2(Sqrt[1-4 x])(3+4x(4x-3)))))/(2 (((1-4 x))^(7/2))))]

Series[(((x^2)+6(x^3))/( 2(((1-4 x))^(7/2))))+((-(x^2)+12 (x^3)-48(x^4)+64(x^5))/(2(((1-4 x))^3))),{x,0,20}]

FullSimplify[(((x^2)+6(x^3))/( 2(((1-4 x))^(7/2))))+((-(x^2)+12 (x^3)-48(x^4)+64(x^5))/(2(((1-4 x))^3))),]

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

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

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

Join[{0,0},RecurrenceTable[{(12+24n)a[n]+(22-2n)a[n+1]==n a[n+2],a[3]==10,a[4]==105},a,{n,3,20}]]

IndependenceNumber

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

seq=Table[GraphData[{"Odd",n},"IndependenceNumber"],{n,7}]

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

FindGeneratingFunction[seq,x]

Table[Binomial[2 n-2,n-2],{n,7}]

FullSimplify[Binomial[2 n-2,n-2]]

IndependenceRatio

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

seq=Table[GraphData[{"Odd",n},"IndependenceRatio"],{n,7}]

FindSequenceFunction[%,n]

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

IndependentEdgeSetCount

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

A293241

seq=Table[GraphData[{"Odd",n},"IndependentEdgeSetCount"],{n,7}]

FindSequenceFunction[DeleteMissing@seq,n]

IndependentVertexSetCount

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

A292711

seq=Table[GraphData[{"Odd",n},"IndependentVertexSetCount"],{n,7}]

IntersectionNumber

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

seq=Table[GraphData[{"Odd",n},"IntersectionNumber"],{n,7}]

KirchhoffIndex

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

seq=Table[GraphData[{"Odd",n},"KirchhoffIndex"],{n,7}]

FindSequenceFunction[%,n]

KirchhoffSumIndex

Entity["Graph",{"Odd",n}]["KirchhoffSumIndex"]

seq=Table[GraphData[{"Odd",n},"KirchhoffSumIndex"],{n,7}]

FindSequenceFunction[%,n]

LeafCount

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

seq=Table[GraphData[{"Odd",n},"LeafCount"],{n,7}]

LongestCycleCount

=== HamiltonianCycleCount except for n==3 (PetersenGraph)

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

seq=Table[GraphData[{"Odd",n},"LongestCycleCount"],{n,7}]

LovaszNumber

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

Table[%,{n,7}]

seq=Table[GraphData[{"Odd",n},"LovaszNumber"],{n,7}]

FindSequenceFunction[Rest@seq,n-1]

(x^2)FindGeneratingFunction[Rest@seq,x]

Table[Binomial[2n-2,n-2],{n,7}]

LucasCube

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

seq=Table[GraphData[{"Odd",n},"LucasCube"],{n,7}]

MatchingNumber

A301560

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

seq=Table[GraphData[{"Odd",n},"MatchingNumber"],{n,7}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

Do[Print[{n,Length@FindIndependentEdgeSet[OddGraph[n]]//Timing}],{n,8}]

seq={0,1,5,17,63,231,858,3217,12155,46189,176358,676039,2600150,10029150};

FindSequenceFunction[Rest@seq,n]

FindGeneratingFunction[seq,x]

FindLinearRecurrence[Rest@seq]

MaximalCliqueCount

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

seq=Table[GraphData[{"Odd",n},"MaximalCliqueCount"],{n,7}]

FindSequenceFunction[seq,n]//FunctionExpand

FindGeneratingFunction[seq,x]

MaximalIndependentEdgeSetCount

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

seq=Table[GraphData[{"Odd",n},"MaximalIndependentEdgeSetCount"],{n,7}]

MaximalIndependentVertexSetCount

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

A290610

seq=Table[GraphData[{"Odd",n},"MaximalIndependentVertexSetCount"],{n,7}]

MaximumCliqueCount

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

seq=Table[GraphData[{"Odd",n},"MaximumCliqueCount"],{n,7}]

FindSequenceFunction[seq,n]

gf=FindGeneratingFunction[seq,x]

Table[n Binomial[2n,n]/4,{n,7}]

MaximumIndependentEdgeSetCount

A297530

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

seq=Table[GraphData[{"Odd",n},"MaximumIndependentEdgeSetCount"],{n,7}]

MaximumIndependentVertexSetCount

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

seq=Table[GraphData[{"Odd",n},"MaximumIndependentVertexSetCount"],{n,7}]

MaximumLeafNumber

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

seq=Table[GraphData[{"Odd",n},"MaximumLeafNumber"],{n,7}]

MaximumVertexDegree

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

seq=Table[GraphData[{"Odd",n},"MaximumVertexDegree"],{n,7}]

MeanDistance

A088459

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

seq=Table[GraphData[{"Odd",n},"MeanDistance"],{n,7}]

d=Table[Tally[Sort@Flatten[GraphDistanceMatrix[OddGraph1[n]]]],{n,5}];//Timing

d//ColumnForm

d[[All,All,2]]/Table[Binomial[2n-1,n-1],{n,5}]

Number of vertices at distance k is

Table[Sum[k Binomial[n,Ceiling[k/2]]Binomial[n-1,Floor[k/2]],{k,n-1}]/Binomial[2n-1,n-1],{n,10}]

Table[Mean@Flatten[GraphData[{"Odd",n},"DistanceMatrix"]],{n,5}]

Table[Binomial[2n-1,n-1]Mean@Flatten[GraphData[{"Odd",n},"DistanceMatrix"]],{n,4}]

Table[Total[GraphData[{"Odd",n},"DistanceMatrix"],2],{n,5}]

distsum=Table[Sum[k Binomial[n,If[Mod[k,2]==0,k/2,(k+1)/2]]Binomial[n-1,If[Mod[k,2]==0,k/2,(k-1)/2]],{k,n-1}],{n,40}]

FindLinearRecurrence[distsum]//Head//Timing

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

seq=Table[Sum[k Binomial[n,Ceiling[k/2]]Binomial[n-1,Floor[k/2]],{k,n-1}],{n,30}]

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

Sum[k Binomial[-1+n,(k/2)] Binomial[n,(k/2)],{k,2,n-1,2}]

Sum[k Binomial[-1+n,(1/2) (-1+k)] Binomial[n,((1+k)/2)],{k,1,n-1,2}]

terms={((2 (-1+n) n Gamma[-1+2 n])/(Gamma[n] Gamma[1+n]))-2 Binomial[-1+n,2+Floor[(1/2) (-3+n)]] Binomial[n,2+Floor[(1/2) (-3+n)]] (2+Floor[(1/2) (-3+n)]) HypergeometricPFQ[{1,2-n+Floor[(1/2) (-3+n)],3-n+Floor[(1/2) (-3+n)]},{3+Floor[(1/2) (-3+n)],3+Floor[(1/2) (-3+n)]},1]-2 Binomial[-1+n,3+Floor[(1/2) (-3+n)]] Binomial[n,3+Floor[(1/2) (-3+n)]] HypergeometricPFQ[{2,3-n+Floor[(1/2) (-3+n)],4-n+Floor[(1/2) (-3+n)]},{4+Floor[(1/2) (-3+n)],4+Floor[(1/2) (-3+n)]},1],((n (Gamma[2 n]+2 (((-1+n))^2) Gamma[-1+2 n]))/((Gamma[1+n])^2))-Binomial[-1+n,Floor[(n/2)]] Binomial[n,1+Floor[(n/2)]] (1+2 Floor[(n/2)]) HypergeometricPFQ[{1,1-n+Floor[(n/2)],1-n+Floor[(n/2)]},{1+Floor[(n/2)],2+Floor[(n/2)]},1]-2 Binomial[-1+n,1+Floor[(n/2)]] Binomial[n,2+Floor[(n/2)]] HypergeometricPFQ[{2,2-n+Floor[(n/2)],2-n+Floor[(n/2)]},{2+Floor[(n/2)],3+Floor[(n/2)]},1]};

Table[terms,{n,7}]

Total/@%

seq=Table[Sum[k Binomial[n,Ceiling[k/2]]Binomial[n-1,Floor[k/2]],{k,n-1}],{n,20}]

Simplify[Refine[Total[terms],Mod[n,2]==0],n∈Integers&&n>0]

FullSimplify[%]

Simplify[Refine[Total[terms],Mod[n,2]==1],n∈Integers&&n>0]

FullSimplify[%]

MinimalDominatingSetCount

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

Probably (3^n)

seq=Table[GraphData[{"Odd",n},"MinimalDominatingSetCount"],{n,7}]

FindSequenceFunction[DeleteMissing@seq,n]

MinimalDominatingSetSignature

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

Probably (3^n)

seq=Table[GraphData[{"Odd",n},"MinimalDominatingSetSignature"],{n,7}]//Column

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

MinimumCliqueCoveringCount

Entity["Graph",{"Odd",n}]["MinimumCliqueCoveringCount"]

seq=Table[GraphData[{"Odd",n},"MinimumCliqueCoveringCount"],{n,7}]

MinimumConnectedDominatingSetCount

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

seq=Table[GraphData[{"Odd",n},"MinimumConnectedDominatingSetCount"],{n,7}]

FindSequenceFunction[DeleteCases[seq,_Missing],n]

MinimumDistinguishingLabelingCount

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

seq=Table[GraphData[{"Odd",n},"MinimumDistinguishingLabelingCount"],{n,7}]

MinimumDominatingSetCount

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

seq=Table[GraphData[{"Odd",n},"MinimumDominatingSetCount"],{n,7}]

MinimumEdgeCoverCount

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

seq=Table[GraphData[{"Odd",n},"MinimumEdgeCoverCount"],{n,7}]

MinimumVertexCoverCount

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

seq=Table[GraphData[{"Odd",n},"MinimumVertexCoverCount"],{n,7}]

MinimumVertexDegree

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

seq=Table[GraphData[{"Odd",n},"MinimumVertexDegree"],{n,7}]

MolecularTopologicalIndex

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

A192835

seq=Table[GraphData[{"Odd",n},"MolecularTopologicalIndex"],{n,7}]

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

FindGeneratingFunction[seq,x]//Factor

(seq=Table[MolecularTopologicalIndex[CombinatoricaGraphToV8Graph@OddGraph[n]],{n,2,8}])//Timing

b(n)=sum(i=1, n-1, binomial(n-1, i)*binomial(n, i)*min(2*i, 2*(n-i)-1));
a(n)=if(n<2, 0, binomial(2*n-1, n)*n*(n+b(n)))

Table[Sum[Binomial[n-1,i]Binomial[n,i]Min[2i,2(n-i)-1],{i,n-1}],{n,2,7}]

seq=Table[Binomial[2n-1,n]n(n+Sum[Binomial[n-1,i]Binomial[n,i]Min[2i,2(n-i)-1],{i,n-1}]),{n,2,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-1]

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

Sum[Binomial[n-1,i]Binomial[n,i]Min[2i,2(n-i)-1],{i,n-1}]

PiecewiseExpand[Min[2 i,-1+2 (-i+n)]]

Solve[2i-n==-1/2,i]

Table[Sum[Binomial[n-1,i]Binomial[n,i]2i,{i,(1/4) (2 n-1)}]+Sum[Binomial[n-1,i]Binomial[n,i](-1-2 i+2 n),{i,Ceiling[(1/4) (2 n-1)],n-1}],{n,2,7}]

sum=Sum[Binomial[n-1,i]Binomial[n,i]2i,{i,(1/4) (2 n-1)}]+Sum[Binomial[n-1,i]Binomial[n,i](-1-2 i+2 n),{i,Ceiling[(1/4) (2 n-1)],n-1}]

FullSimplify[sum,Mod[n,2]==0]

FullSimplify[sum,Mod[n,2]==1]

Nonhamiltonian

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

Table[GraphData[{"Odd",n},"Nonhamiltonian"],{n,7}]

OddChordlessCycleCount

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

seq=Table[GraphData[{"Odd",n},"OddChordlessCycleCount"],{n,7}]

PathCount

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

seq=Table[GraphData[{"Odd",n},"PathCount"],{n,7}]

PathPolynomial

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

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

poly2=Table[XXX,{n,k0,kmax}]

FullSimplify[poly2-poly]

Pell

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

seq=Table[GraphData[{"Odd",n},"Pell"],{n,7}]

PentagonCount

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

seq=Table[GraphData[{"Odd",n},"PentagonCount"],{n,7}]

ProjectivePlaneCrossingNumber

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

seq=Table[GraphData[{"Odd",n},"ProjectivePlaneCrossingNumber"],{n,7}]

Radius

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

seq=Table[GraphData[{"Odd",n},"Radius"],{n,7}]

RectilinearCrossingNumber

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

seq=Table[GraphData[{"Odd",n},"RectilinearCrossingNumber"],{n,7}]

SpanningTreeCount

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

A193149

seq=Table[GraphData[{"Odd",n},"SpanningTreeCount"],{n,7}]

FindSequenceFunction[Take[seq,5],n]

FindGeneratingFunction[Take[seq,6],x]

SpectralRadius

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

seq=Table[GraphData[{"Odd",n},"SpectralRadius"],{n,7}]

SquareCount

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

seq=Table[GraphData[{"Odd",n},"SquareCount"],{n,7}]

StabilityIndex

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

seq=Table[GraphData[{"Odd",n},"StabilityIndex"],{n,7}]

FindSequenceFunction[%,n]

FindGeneratingFunction[seq,x]

TopologicalIndex

Entity["Graph",{"Odd",n}]["TopologicalIndex"]

seq=Table[GraphData[{"Odd",n},"TopologicalIndex"],{n,7}]

FindSequenceFunction[seq,n]

FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

Entity["Graph",{"Odd",n}]["ToroidalCrossingNumber"]

seq=Table[GraphData[{"Odd",n},"ToroidalCrossingNumber"],{n,7}]

Traceable

Entity["Graph",{"Odd",n}]["Traceable"]

Table[GraphData[{"Odd",n},"Traceable"],{n,7}]

TriangleCount

Entity["Graph",{"Odd",n}]["TriangleCount"]

seq=Table[GraphData[{"Odd",n},"TriangleCount"],{n,7}]

Untraceable

Entity["Graph",{"Odd",n}]["Untraceable"]

Table[GraphData[{"Odd",n},"Untraceable"],{n,7}]

VertexConnectivity

Entity["Graph",{"Odd",n}]["VertexConnectivity"]

Table[GraphData[{"Odd",n},"VertexConnectivity"],{n,7}]

VertexCount

Entity["Graph",{"Odd",n}]["VertexCount"]

seq=Table[GraphData[{"Odd",n},"V"],{n,7}]

FindSequenceFunction[%,n]

FullSimplify[%]

FunctionExpand[%]//FullSimplify

FindGeneratingFunction[seq,x]

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

Table[Binomial[2n-1,n-1],{n,5}]

VertexCoverCount

===IndependentVertexSetCount

A292711

Entity["Graph",{"Odd",n}]["VertexCoverCount"]

seq=Table[GraphData[{"Odd",n},"VertexCoverCount"],{n,7}]

FindSequenceFunction[Drop[seq,-3]]

FindGeneratingFunction[Drop[seq,-3],x]

VertexCoverNumber

Entity["Graph",{"Odd",n}]["VertexCoverNumber"]

seq=Table[GraphData[{"Odd",n},"VertexCoverNumber"],{n,7}]

FindSequenceFunction[seq,n]//FullSimplify

Table[Binomial[2n-2,n-1],{n,7}]

gf=x FindGeneratingFunction[seq,x]

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

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

FunctionExpand[(((-4))^(-1+n)) Binomial[-(1/2),-1+n]]//FullSimplify

VertexDegrees

Entity["Graph",{"Odd",n}]["VertexDegrees"]

seq=Table[GraphData[{"Odd",n},"VertexDegrees"],{n,7}]

%===Table[Piecewise[{{ConstantArray[n,Binomial[2 n-1,n-1]],n>1}},{0}],{n,7}]

WienerIndex

Entity["Graph",{"Odd",n}]["WienerIndex"]

A136328

seq=Table[GraphData[{"Odd",n},"WienerIndex"],{n,7}]

seq={0,3,75,1435,25515,436821,7339332,121782375,2005392675,32835436777,535550923908,8707954925033,141270179732500,2287544190032700,36988236910737360,597341791692978975,9637351741503033075 };

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

FindLinearRecurrence[seq]

FindLinearRecurrence[Rest@seq]

Table[1/2 Binomial[2 n-1,n-1] (Sum[((2 j+1) n)/(j+1) Binomial[n-1,j]^2,{j,0,Floor[(n-2)/2]}]+Sum[(2 (n-1-j) n)/(j+1) Binomial[n-1,j]^2,{j,1+Floor[(n-2)/2],n-2}]),{n,20}]

Table[Sum[k Binomial[n,Ceiling[k/2]]Binomial[n-1,Floor[k/2]]Binomial[2n-1,n-1]/2,{k,n-1}],{n,10}]

Take[seq=Table[Binomial[2n-1,n-1]/2(Sum[((2j+1)n)/(j+1)Binomial[n-1,j]^2,{j,0,Floor[n/2]-1}]+Sum[(2(n-1-j)n)/(j+1)Binomial[n-1,j]^2,{j,Floor[n/2],n-2}]),{n,100}],20]

Head/@Table[FindLinearRecurrence[Drop[seq,k]],{k,0,4}]

FindGeneratingFunction[seq,x]

Refine[Floor[(k-2)/2],Mod[k,2]==#]&/@{0,1}//Simplify

(1/2) (-3+k)+1//Simplify

FullSimplify[(1/2)Binomial[2k-1,k-1](Sum[(((2j+1)k)/(j+1))((Binomial[k-1,j])^2),{j,0,k/2-1}]+Sum[((2(k-1-j)k)/(j+1))((Binomial[k-1,j])^2),{j,k/2,k-2}])]

FullSimplify[(1/2)Binomial[2k-1,k-1](Sum[(((2j+1)k)/(j+1))((Binomial[k-1,j])^2),{j,0,(1/2) (-3+k)}]+Sum[((2(k-1-j)k)/(j+1))((Binomial[k-1,j])^2),{j,(1/2) (-1+k),k-2}])]

Table[k Binomial[-1+2 k,-1+k] Piecewise[{{((((-1+k) (1+2 (-1+k) k) Gamma[-2+2 k])/((Gamma[1+k])^2))-((3 ((Binomial[-1+k,(k/2)])^2) HypergeometricPFQ[{1,1-(k/2),1-(k/2)},{1+(k/2),2+(k/2)},1])/(2+k))-((4 ((Binomial[-1+k,1+(k/2)])^2) HypergeometricPFQ[{2,2-(k/2),2-(k/2)},{2+(k/2),3+(k/2)},1])/(4+k))),Mod[k,2]==0},{((((-1+k) (1+2 (-1+k) k) Gamma[-2+2 k])/((Gamma[1+k])^2))-((((Binomial[-1+k,(1/2) (-1+k)])^2) HypergeometricPFQ[{1,(1/2)-(k/2),(1/2)-(k/2)},{(1/2)+(k/2),(3/2)+(k/2)},1])/(1+k))-((4 ((Binomial[-1+k,((1+k)/2)])^2) HypergeometricPFQ[{2,(3/2)-(k/2),(3/2)-(k/2)},{(3/2)+(k/2),(5/2)+(k/2)},1])/(3+k))),Mod[k,2]==1}}],{k,10}]

WienerSumIndex

Entity["Graph",{"Odd",n}]["WienerSumIndex"]

seq=Table[GraphData[{"Odd",n},"WienerSumIndex"],{n,5}]

FindSequenceFunction[seq,n]

GraphData

GraphClassString

GraphData["Odd"]

GraphClassString[GraphData["Odd"]]

GraphDataString

Do[Print[GraphDataString[OddGraph[n],{{"Odd",n},ToString[n]<>"-odd graph","OddGraph"},TimeConstraint->60]],{n,2,20}]