Folded Cube Graph

Author

Eric W. Weisstein
March 21, 2018

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

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

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

Definitions

Bouwer

http://www.win.tue.nl/~aeb/drg/graphs/Folded-6-cube.html

The full group of automorphisms of the folded 6-cube is 25.S6 of order 23040, acting distance-transitively with point stabilizer S6. The other two designs have transitive groups of order 1536 and 768, respectively.

The folded 6-cube is the result of identifying the antipodes in the 6-cube.

According to ref/VertexContract, VertexContract is also known as vertex identification.  But applying VertexContract here gives a singleton graph.

VertexContract[g, {v1, v2, ...}] creates a new graph from g by removing all edges between (Subscript[v, i]) and (Subscript[v, j]) and merging them into the single vertex (Subscript[v, 1]).

?VertexContract

h=HypercubeGraph[2,VertexLabels->"Name"]

d=GraphDistanceMatrix[h]

Union[Sort/@Position[d,2]]

d=GraphDistanceMatrix[HypercubeGraph[6]];

vs=Union[Sort/@Position[d,6]]

VertexContract[HypercubeGraph[6],vs]

Times@@HoldForm/@(#1^HoldForm[#2]&@@@Tally[GraphData[{"FoldedCube",6},"Spectrum"]])

There are precisely three distance-regular graphs with intersection array {6,5,4;1,2,6}.

IntersectionArray[GraphData[{"FoldedCube",6}]]

Godsil [different definition?]

We introduce the folded cubes. We view the cube as a graph with the subsets of {1, . . . , n} as its vertices, where subsets S and T are adjacent if and only if |S∆T | = 1. Each subset S determines a partition (S, S) of {1, . . . , n} with two cells; the folded cube is the graph with these partitions as its vertices, where two partitions are adjacent if a cell of one is adjacent to a cell of the other in the n-cube

The folded 3-cube is K4 and the folded 5-cube is the Clebsch graph.

The chromatic number of the folded (2r + 1)-cube is 4.

Table[GraphData[{"FoldedCube",n},"ChromaticNumber"],{n,2,10}]

HypercubeGraph[4]//VertexCount

HypercubeGraph[4]//EdgeCount

v=Subsets[Range[4]]

e=Select[Subsets[v,{2}],(Length[#[[1]]]==Length[#[[2]]]&&Length[DeleteCases[Transpose[#],{x_,x_}]]==1)&]

Length[e]

UndirectedEdge@@@e

g=System`Graph[v,UndirectedEdge@@@e]

VertexDegree[g]

Construction timings

Grid[Table[{n,(
h=HypercubeGraph[n])//Timing//First,
GraphDistanceMatrix[h]//Timing//First,
EdgeList[h]//Timing//First,
FoldedCubeGraph[n]//Timing//First
},{n,2,12}]]

Graphics

GraphicsRow[Table[FoldedCubeGraph[n,VertexSize->If[n==1,.015,{"Scaled",.05}],System`VertexStyle->Red,System`EdgeStyle->Black],{n,5}],Dividers->All,ImageSize->500]

GraphicsRow[Table[Show[GraphData[{"FoldedCube",n}]/.g_System`Graph:>SetProperty[g,{VertexSize->If[n==1,.015,{"Scaled",.07}],System`VertexStyle->Red,System`EdgeStyle->Black}],
PlotLabel->TextCell[Column[{Subscript[Style["F",Italic],n],Style[GraphData[{"FoldedCube",n},"Name"],Italic]},Alignment->Center],PageWidth->100,TextAlignment->Center],BaseStyle->FontFamily->"Times"],{n,2,6}],Dividers->All,ImageSize->500,Alignment->Top]

Embeddings

Images

l=Select[SortBy[GraphData["FoldedCube"],GraphData[#,"V"]&],GraphData[#,"Embeddings"]=!={}&]

GraphData["KummerGraph","AllImages"]

GraphicsGrid[Partition[GraphPlot[Graph[#],Method->None,PlotLabel->TextCell[Column[{Subscript["F",ToString["FoldedCube"/.GraphData[#,"NotationRules"]]],GraphData[#,"Name"]},Alignment->Center],PageWidth->100,TextAlignment->Center]]&/@l,4,4,{1,1},{}],ImageSize->400,BaseStyle->Italic,Spacings->-50]

LCF

TextGrid[Table[{n,GraphData[{"FoldedCube",n},"LCFSignature"]},{n,2,10}],Dividers->All]

TextGrid[Table[{n,GraphData[{"FoldedCube",n},"HamiltonianCycleCount"]},{n,2,10}]]

Special Cases

RecognizeGraph/@Table[FoldedCubeGraph[n],{n,10}]

With[{cl="FoldedCube"},TextGrid[Sort[{cl/.GraphData[#,"NotationRules"],GraphData[#,"Name"]}&/@DeleteCases[GraphData[cl],{cl,_}]],Dividers->All]]

Properties

Acyclic

seq=Table[GraphData[{"FoldedCube", n},"Acyclic"],{n,2,10}]

AdjacencyMatrixCount

seq=Table[GraphData[{"FoldedCube", n},"AdjacencyMatrixCount"],{n,2,10}]

ArcTransitive

seq=Table[GraphData[{"FoldedCube", n},"ArcTransitive"],{n,2,10}]

ArcTransitivity

seq=Table[GraphData[{"FoldedCube", n},"ArcTransitivity"],{n,2,10}]

AutomorphismCount

seq=Table[GraphData[{"FoldedCube", n},"AutomorphismCount"],{n,2,10}]

(seq=Table[GroupOrder[GraphAutomorphismGroup[FoldedCubeGraph[n]]],{n,2,12}])//Timing

FindLinearRecurrence[seq]//Head

FindLinearRecurrence[Rest@seq]//Head

FindLinearRecurrence[seq]//Head

FindSequenceFunction[seq,n-1]

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

BalabanIndex

seq=Table[GraphData[{"FoldedCube", n},"BalabanIndex"],{n,2,10}]

(seq=Table[BalabanIndex[FoldedCubeGraph[n]],{n,2,12}])//Timing

FindSequenceFunction[Rest@seq,n-2]

Bandwidth

seq=Table[GraphData[{"FoldedCube", n},"Bandwidth"],{n,2,10}]

BridgeCount

seq=Table[GraphData[{"FoldedCube", n},"BridgeCount"],{n,2,10}]

BurningNumber

seq=Table[GraphData[{"FoldedCube", n},"BurningNumber"],{n,2,10}]

CharacteristicPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"CharacteristicPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

Chordal

seq=Table[GraphData[{"FoldedCube", n},"Chordal"],{n,2,10}]

ChordCount

Probably EdgeCount

Table[GraphData[{"FoldedCube", n},"EdgeCount"],{n,2,10}]

seq=Table[GraphData[{"FoldedCube", n},"ChordCount"],{n,2,10}]

Chordless

seq=Table[GraphData[{"FoldedCube", n},"Chordless"],{n,2,10}]

ChordlessCycleCount

seq=Table[GraphData[{"FoldedCube",n},"ChordlessCycleCount"],{n,2,10}]

FindSequenceFunction[seq,n-1]

Chords

seq=Table[GraphData[{"FoldedCube", n},"Chords"],{n,2,10}]

ChromaticallyUnique

seq=Table[GraphData[{"FoldedCube", n},"ChromaticallyUnique"],{n,2,10}]

GraphData[{"ChromaticallyUnique","FoldedCube"}]

ChromaticInvariant

A295172

seq=Table[GraphData[{"FoldedCube",n},"ChromaticInvariant"],{n,2,10}]

FindSequenceFunction[DeleteMissing[seq],n]

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

ChromaticNumber

seq=Table[GraphData[{"FoldedCube",n},"ChromaticNumber"],{n,2,10}]

ChromaticPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"ChromaticPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

Circumference

seq=Table[GraphData[{"FoldedCube", n},"Circumference"],{n,2,10}]

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

Classes

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

CliqueCount

A295921

seq=Table[GraphData[{"FoldedCube", n},"CliqueCount"],{n,2,10}]

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

gf=x FindGeneratingFunction[seq,x]

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

CliqueCoveringNumber

seq=Table[GraphData[{"FoldedCube",n},"CliqueCoveringNumber"],{n,2,10}]

CliqueNumber

seq=Table[GraphData[{"FoldedCube", n},"CliqueNumber"],{n,2,10}]

CliquePolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"CliquePolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[Drop[poly,3]]

cols=Transpose[CoefficientList[Drop[poly,3],x]]

{1,x,x^2}.(FindSequenceFunction[#,n-4]&/@cols)//FullSimplify

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

CochromaticGraphNames

Table[GraphData[{"FoldedCube", n},"CochromaticGraphNames"],{n,2,10}]

Select[GraphData["FoldedCube"],GraphData[#,"ChromaticallyUnique"]=!=False&]

ComplementOddChordlessCycleCount

seq=Table[GraphData[{"FoldedCube", n},"ComplementOddChordlessCycleCount"],{n,2,10}]

FindSequenceFunction[Take[seq,{3,5}],n]

ConnectedComponentCount

seq=Table[GraphData[{"FoldedCube", n},"ConnectedComponentCount"],{n,2,10}]

ConnectedDominatingSetCount

A298114

seq=Table[GraphData[{"FoldedCube", n},"ConnectedDominatingSetCount"],{n,2,10}]

FindSequenceFunction[seq,n-1]

ConnectedDominationNumber

seq=Table[GraphData[{"FoldedCube", n},"ConnectedDominationNumber"],{n,2,10}]

FindSequenceFunction[seq,n-1]

ConnectedDominationPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

A290970

seq=Table[GraphData[{"FoldedCube",n},"ConnectedInducedSubgraphCount"],{n,2,10}]

ConnectedInducedSubgraphPolynomial

Looks very amenable to cloded-form finfing

(poly=Factor[Table[GraphData[{"FoldedCube", n},"CharacteristicPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

poly2=Table[XXX,{n,2,10}]

FullSimplify[poly2-poly]

CrossingNumber

seq=Table[GraphData[{"FoldedCube", n},"CrossingNumber"],{n,2,10}]

CycleCount

A234619

seq=Table[GraphData[{"FoldedCube",n},"CycleCount"],{n,2,10}]

CyclePolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"CyclePolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

Cyclic

Table[GraphData[{"FoldedCube", n},"Cyclic"],{n,2,10}]

CyclomaticNumber

seq=Table[GraphData[{"FoldedCube", n},"CyclomaticNumber"],{n,2,10}]

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

DetourIndex

A296778

seq=Table[GraphData[{"FoldedCube", n},"DetourIndex"],{n,2,10}]

FindSequenceFunction[{1,18,184,1800,15136,127008},n-1]//FullSimplify

DetourMatrix

MatrixForm/@Table[GraphData[{"FoldedCube", n},"DetourMatrix"],{n,2,10}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,2,10}]

DetourPolynomial

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

FindSequenceFunction[{1,9,49,225,961,3969},n-1]

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

Diameter

seq=Table[GraphData[{"FoldedCube", n},"Diameter"],{n,2,10}]

(seq=Table[GraphDiameter[FoldedCubeGraph[n]],{n,2,13}])//Timing

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

DistanceMatrix

MatrixForm/@Table[GraphData[{"FoldedCube", n},"DistanceMatrix"],{n,2,10}]

MatrixForm/@Table[SparseArray[{i_,j_}:>Abs[i-j],n],{n,2,10}]

DistancePolynomial

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

FindSequenceFunction[{1,3,8,20,48,112,256,576},n-1]

FindSequenceFunction[{3,10,25,56,119,246,501},n-3]

(poly=Factor@Table[Piecewise[{{-x,n==1},{(x-1)(x+1),n==2}},(x-(2^(n-3)) n)(x^(-1+(2^(-1+n))-n))((((2^(n-3))+x))^n)],{n,kmax}])//Column

DistinguishingNumber

seq=Table[GraphData[{"FoldedCube", n},"DistinguishingNumber"],{n,2,10}]

DominatingSetCount

A301457

seq=Table[GraphData[{"FoldedCube",n},"DominatingSetCount"],{n,2,10}]

FindSequenceFunction[DeleteMissing[seq],n]

gf=x FindGeneratingFunction[DeleteMissing[seq],x]

DominationNumber

a(1) is probably (2^7)

seq=Table[GraphData[{"FoldedCube",n},"DominationNumber"],{n,2,10}]

DominationPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"DominationPolynomial"],{n,k0=2,kmax=10}]/.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]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

EdgeChromaticNumber

seq=Table[GraphData[{"FoldedCube", n},"EdgeChromaticNumber"],{n,2,10}]

EdgeConnectivity

Table[GraphData[{"FoldedCube", n},"EdgeConnectivity"],{n,2,10}]

EdgeCount

A057711

seq=Table[GraphData[{"FoldedCube", n},"EdgeCount"],{n,2,10}]

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

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

EdgeCoverCount

A297052

seq=Table[GraphData[{"FoldedCube", n},"EdgeCoverCount"],{n,2,10}]

EdgeCoverNumber

seq=Table[GraphData[{"FoldedCube", n},"EdgeCoverNumber"],{n,2,10}]

FindSequenceFunction[seq,n-1]

EdgeCoverPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

EulerianCycleCount

seq=Table[GraphData[{"FoldedCube", n},"EulerianCycleCount"],{n,2,10}]

FaceCount

seq=Table[GraphData[{"FoldedCube", n},"FaceCount"],{n,2,10}]

FlowPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

FractionalChromaticNumber

Even terms are 2

seq=Table[GraphData[{"FoldedCube", n},"FractionalChromaticNumber"],{n,2,10}]

FindSequenceFunction[seq,n-1]

FractionalEdgeChromaticNumber

seq=Table[GraphData[{"FoldedCube", n},"FractionalEdgeChromaticNumber"],{n,2,10}]

Girth

seq=Table[GraphData[{"FoldedCube", n},"Girth"],{n,2,10}]

Gonality

seq=Table[GraphData[{"FoldedCube", n},"Gonality"],{n,2,10}]

HamiltonConnected

seq=Table[GraphData[{"FoldedCube", n},"HamiltonConnected"],{n,2,10}]

HamiltonDecompositionCount

seq=Table[GraphData[{"FoldedCube", n},"HamiltonDecompositionCount"],{n,2,10}]

Hamiltonian

Table[GraphData[{"FoldedCube", n},"Hamiltonian"],{n,2,10}]

HamiltonianCycleCount

A280847(n)/2

seq=Table[GraphData[{"FoldedCube", n},"HamiltonianCycleCount"],{n,2,10}]

2DeleteMissing[seq]

HamiltonianNumber

seq=Table[GraphData[{"FoldedCube", n},"HamiltonianNumber"],{n,2,10}]

FindSequenceFunction[seq,n-1]

HamiltonianPathCount

A137887(n)/2

seq=Table[GraphData[{"FoldedCube", n},"HamiltonianPathCount"],{n,2,10}]

2DeleteMissing[seq]

HamiltonianWalkCount

seq=Table[GraphData[{"FoldedCube", n},"HamiltonianWalkCount"],{n,2,10}]

HararyIndex

seq=Table[GraphData[{"FoldedCube", n},"HararyIndex"],{n,2,10}]

(seq=Table[HararyIndex[FoldedCubeGraph[n]],{n,2,10}])//Timing

(seq=Table[HararyIndex[FoldedCubeGraph[n]],{n,12}])//Timing

FindSequenceFunction[seq,n-1]

HexagonCount

A301459

seq=Table[GraphData[{"FoldedCube", n},"HexagonCount"],{n,2,10}]

Do[Print[{{"FoldedCube",n},CycleCount[FoldedCubeGraph[n],6]//Timing}],{n,2,14}]

seq={0,0,96,320,3200,4480,14336,43008,122880,337920,901120,2342912,5963776,14909440};

gf=(x^2) FindGeneratingFunction[seq,x,ValidationLength->3]//Factor

gf//InputForm

CoefficientList[Series[((32 (x^2) (3-14 x+92 (x^2)-516 (x^3)+1456 (x^4)-1920 (x^5)+960 (x^6)))/(((-1+2 x))^4)),{x,0,20}],x]

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

seq=Table[Piecewise[{{0,n==3},{96,n==4},{3200,n==6}},(2^(n-1))n(n-1)(n-2)/3],{n,2,20}]

FindLinearRecurrence[Drop[seq,5]]

Join[{0,0,96,320,3200},LinearRecurrence[{8,-24,32,-16},{4480,14336,43008,122880,337920},30]]

IdiosyncraticPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"IdiosyncraticPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x,y]])//Column

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

IndependenceNumber

A058622

seq=Table[GraphData[{"FoldedCube", n},"IndependenceNumber"],{n,2,10}]

seq=Table[(2^(n-1))-(1+(((-1))^n))Binomial[n,n/2]/4,{n,0,30}]

FindLinearRecurrence[seq]

FindGeneratingFunction[seq,x]

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

SeriesCoefficient[((2 x)/((1-2 x) (1+2 x+(Sqrt[(1+2 x) (1-2 x)])))),{x,0,n}]

IndependencePolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"IndependencePolynomial"],{n,k0=2,kmax=10}]/.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]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

IndependenceRatio

seq=Table[GraphData[{"FoldedCube", n},"IndependenceRatio"],{n,2,10}]

(((2^(n-1))-(1+(((-1))^n))Binomial[n,n/2]/4)/(2^n))/.n->n-1//Simplify

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

IndependentEdgeSetCount

A293148

seq=Table[GraphData[{"FoldedCube",n},"IndependentEdgeSetCount"],{n,2,10}]

IndependentVertexSetCount

A290888

seq=Table[GraphData[{"FoldedCube",n},"IndependentVertexSetCount"],{n,2,10}]

FindSequenceFunction[DeleteMissing@seq,n]

IntersectionNumber

seq=Table[GraphData[{"FoldedCube", n},"IntersectionNumber"],{n,2,10}]

KirchhoffIndex

seq=Table[GraphData[{"FoldedCube", n},"KirchhoffIndex"],{n,2,10}]

(seq=Table[KirchhoffIndex[FoldedCubeGraph[n]],{n,2,9}])//Timing

FindSequenceFunction[seq,n-1]

KirchhoffSumIndex

seq=Table[GraphData[{"FoldedCube", n},"KirchhoffSumIndex"],{n,2,10}]

(seq=Table[KirchhoffIndex[FoldedCubeGraph[n]],{n,2,9}])//Timing

FindSequenceFunction[seq,n-1]

LaplacianMatrix

MatrixForm/@Table[GraphData[{"FoldedCube", n},"LaplacianMatrix"],{n,2,10}]

LaplacianPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"LaplacianPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

LeafCount

seq=Table[GraphData[{"FoldedCube", n},"LeafCount"],{n,2,10}]

LongestCycleCount

===HamiltonianCycleCount

seq=Table[GraphData[{"FoldedCube", n},"LongestCycleCount"],{n,2,10}]

LovaszNumber

seq=Table[GraphData[{"FoldedCube", n},"LovaszNumber"],{n,2,10}]

MatchingGeneratingPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

MatchingNumber

seq=Table[GraphData[{"FoldedCube", n},"MatchingNumber"],{n,2,10}]

FindSequenceFunction[Rest@seq,n-1]

MatchingPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"MatchingPolynomial"],{n,k0=2,kmax=10}]/.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]

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

MaximalCliqueCount

A057711

seq=Table[GraphData[{"FoldedCube", n},"MaximalCliqueCount"],{n,2,10}]

FindSequenceFunction[seq,n-1]

SeriesCoefficient[FindGeneratingFunction[seq,x],{x,0,n}]

MaximalIndependentEdgeSetCount

A297481

seq=Table[GraphData[{"FoldedCube", n},"MaximalIndependentEdgeSetCount"],{n,2,10}]

MaximalIndependentVertexSetCount

A301460

seq=Table[GraphData[{"FoldedCube", n},"MaximalIndependentVertexSetCount"],{n,2,10}]

MaximumCliqueCount

A057711

seq=Table[GraphData[{"FoldedCube", n},"MaximumCliqueCount"],{n,2,10}]

MaximumIndependentEdgeSetCount

A297561

seq=Table[GraphData[{"FoldedCube", n},"MaximumIndependentEdgeSetCount"],{n,2,10}]

MaximumIndependentVertexSetCount

seq=Table[GraphData[{"FoldedCube", n},"MaximumIndependentVertexSetCount"],{n,2,10}]

MaximumLeafNumber

seq=Table[GraphData[{"FoldedCube", n},"MaximumLeafNumber"],{n,2,10}]

MaximumVertexDegree

seq=Table[GraphData[{"FoldedCube", n},"MaximumVertexDegree"],{n,2,10}]

MeanDistance

seq=Table[GraphData[{"FoldedCube", n},"MeanDistance"],{n,2,10}]

FindSequenceFunction[Rest@seq,n-1]

MinimumCliqueCoveringCount

seq=Table[GraphData[{"FoldedCube", n},"MinimumCliqueCoveringCount"],{n,2,10}]

MinimumConnectedDominatingSetCount

seq=Table[GraphData[{"FoldedCube", n},"MinimumConnectedDominatingSetCount"],{n,2,10}]

FindSequenceFunction[seq,n-1]

MinimumDistinguishingLabelingCount

seq=Table[GraphData[{"FoldedCube", n},"MinimumDistinguishingLabelingCount"],{n,2,10}]

MinimumDominatingSetCount

seq=Table[GraphData[{"FoldedCube", n},"MinimumDominatingSetCount"],{n,2,10}]

MinimumEdgeCoverCount

seq=Table[GraphData[{"FoldedCube", n},"MinimumEdgeCoverCount"],{n,2,10}]

MinimumVertexDegree

seq=Table[GraphData[{"FoldedCube", n},"MinimumVertexDegree"],{n,2,10}]

MolecularTopologicalIndex

A192826

seq=Table[GraphData[{"FoldedCube",n},"MolecularTopologicalIndex"],{n,2,10}]

Nonhamiltonian

Table[GraphData[{"FoldedCube", n},"Nonhamiltonian"],{n,2,10}]

NormalizedLaplacianMatrix

MatrixForm/@Table[GraphData[{"FoldedCube", n},"NormalizedLaplacianMatrix"],{n,2,5}]

OddChordlessCycleCount

seq=Table[GraphData[{"FoldedCube", n},"OddChordlessCycleCount"],{n,2,10}]

PathCount

A301377

seq=Table[GraphData[{"FoldedCube", n},"PathCount"],{n,2,10}]

PathPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

PentagonCount

seq=Table[GraphData[{"FoldedCube", n},"PentagonCount"],{n,2,10}]

(seq=Table[CycleCount[FoldedCubeGraph[n],5],{n,2,12}])//Timing

Perfect

Table[GraphData[{"FoldedCube", n},"Perfect"],{n,2,10}]

ProjectivePlaneCrossingNumber

seq=Table[GraphData[{"FoldedCube", n},"ProjectivePlaneCrossingNumber"],{n,2,10}]

Radius

seq=Table[GraphData[{"FoldedCube", n},"Radius"],{n,2,10}]

RankPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

RectilinearCrossingNumber

seq=Table[GraphData[{"FoldedCube", n},"RectilinearCrossingNumber"],{n,2,10}]

ReliabilityPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

SigmaPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"SigmaPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

SpanningTreeCount

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

FindSequenceFunction[Take[seq,7],n]

FindGeneratingFunction[Take[seq,7],x]

SquareCount

A052482

seq=Table[GraphData[{"FoldedCube", n},"SquareCount"],{n,2,10}]

(seq=Table[CycleCount[FoldedCubeGraph[n],4],{n,2,12}])//Timing

FindLinearRecurrence[seq]

FindLinearRecurrence[Drop[seq,3]]

Join[{LinearRecurrence[{6,-12,8},{40,120,336},20]

LinearRecurrence[{6,-12,8},{(9/4),0,3},{2,10}]

FindSequenceFunction[seq,n-1]

FindSequenceFunction[Rest@seq,n-1]

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

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

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

seq=Table[2^(n-2) Binomial[n+1,2],{n,2,28}]

FindLinearRecurrence[seq]

LinearRecurrence[{6,-12,8},{3,12,40},20]

FindGeneratingFunction[seq,x]

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

StabilityIndex

seq=Table[GraphData[{"FoldedCube", n},"StabilityIndex"],{n,2,10}]

FindSequenceFunction[seq,n-1]

FindGeneratingFunction[seq,x]

TopologicalIndex

seq=Table[GraphData[{"FoldedCube", n},"TopologicalIndex"],{n,2,10}]

FindSequenceFunction[seq,n-1]

FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

seq=Table[GraphData[{"FoldedCube", n},"ToroidalCrossingNumber"],{n,2,10}]

Traceable

Table[GraphData[{"FoldedCube", n},"Traceable"],{n,2,10}]

TriangleCount

seq=Table[GraphData[{"FoldedCube", n},"TriangleCount"],{n,2,10}]

TuttePolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

Untraceable

Table[GraphData[{"FoldedCube", n},"Untraceable"],{n,2,10}]

VertexConnectivity

Table[GraphData[{"FoldedCube", n},"VertexConnectivity"],{n,2,10}]

VertexCount

seq=Table[GraphData[{"FoldedCube", n},"VertexCount"],{n,2,10}]

FindSequenceFunction[seq,n-1]

VertexCoverNumber

A027306

vertex cover number == vertex count - independence number

seq=Table[GraphData[{"FoldedCube", n},"VertexCoverNumber"],{n,2,10}]

FindSequenceFunction[seq,n-1]//FullSimplify

gf=x FindGeneratingFunction[seq,x]

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

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

VertexCoverPolynomial

(poly=Factor[Table[GraphData[{"FoldedCube", n},"VertexCoverPolynomial"],{n,k0=2,kmax=10}]/.f_Function:>f[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

Factor[Take[poly2-poly,kmax-k0-Count[poly,_Missing]+1]]

FullSimplify[poly2-poly]

VertexDegrees

seq=Table[GraphData[{"FoldedCube", n},"VertexDegrees"],{n,2,5}]

VertexTransitive

Table[GraphData[{"FoldedCube", n},"VertexTransitive"],{n,2,10}]

WienerIndex

A292029

seq=Table[GraphData[{"FoldedCube",n},"WienerIndex"],{n,2,10}]

Do[Print[{{"FoldedCube",n},WienerIndex[FoldedCubeGraph[n]]//Timing}],{n,2,20}]

seq={1,6,40,200,1056,4928,23808,107136,494080,2173952,9744384,42225664,185679872,795770880,3451518976,14668955648};

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

seq=Table[DifferenceRoot[Function[{\[FormalY],\[FormalN]},{(-512-256 \[FormalN]) \[FormalY][\[FormalN]]+(320+128 \[FormalN]) \[FormalY][1+\[FormalN]]+(-28-8 \[FormalN]) \[FormalY][3+\[FormalN]]+(4+\[FormalN]) \[FormalY][4+\[FormalN]]==0,\[FormalY][1]==1,\[FormalY][2]==6,\[FormalY][3]==40,\[FormalY][4]==200}]][n],{n,100}]

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

(gf=x FindGeneratingFunction[seq,x])//Timing

FullSimplify[gf]

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

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

FunctionExpand[%155,n>0]

Table[DifferenceRoot[Function[{\[FormalY],\[FormalN]},{(-1+\[FormalN]) (-1+(((-1))^n)+2 \[FormalN]-2 n) \[FormalY][\[FormalN]]-(-1+\[FormalN]) (-1+(((-1))^n)+2 \[FormalN]-2 n) \[FormalY][1+\[FormalN]]-(2+\[FormalN]) (-5+(((-1))^n)+2 \[FormalN]-2 n) \[FormalY][2+\[FormalN]]+(2+\[FormalN]) (-5+(((-1))^n)+2 \[FormalN]-2 n) \[FormalY][3+\[FormalN]]==0,\[FormalY][-1]==0,\[FormalY][0]==0,\[FormalY][1]==(4^n) (5+(((-1))^(1+n))+2 n)}]][2+n],{n,100}]

FindLinearRecurrence[%]

x FindGeneratingFunction[%%,x]

seq=Table[(2^(n-3))n((2^(n-1))-Binomial[n-1,Floor[(n-1)/2]]),{n,2,60}]

FullSimplify[(x^2)FindGeneratingFunction[seq,x]]

FindLinearRecurrence[Drop[seq,3]]

WienerSumIndex

seq=Table[GraphData[{"FoldedCube", n},"WienerSumIndex"],{n,2,10}]

FindSequenceFunction[seq,n-1]

GraphData

GraphClassString

GraphData["FoldedCube"]

GraphClassString[GraphData["FoldedCube"]]

GraphClassString[Drop[SortBy[GraphData["FoldedCube"],GraphData[#,"V"]&],2]]

GraphDataString

file=OpenWrite["flodedcube.m"]

Subscript["\[Square]",2]

Do[WriteString[file,GraphDataString[FoldedCube[n],
"StandardName"->{"FoldedCube",n},
"Name"->"folded "<>ToString[n]<>"-cube",
"Information"->"FoldedCubeGraph",
"Classes"->{"FoldedCube"},
"NotationRules"->{"FoldedCube"->n},
"Notation"->Subscript["\[Square]",n],
Debug->True,
TimeConstraint->30
]],{n,7,10}]

Close[file]