Halved Cube Graph

Author

Eric W. Weisstein
October 21, 2023

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

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

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

Graphics

Graphs.m

GraphicsRow[Table[HalvedCubeGraph[n]//StyleGraphs,{n,5}],Dividers->All,ImageSize->500]

GraphData

GraphicsRow[Table[GraphData[{"HalvedCube",n}]//StyleGraphs,{n,5}],Dividers->All,ImageSize->500]

GraphicsRow[Table[With[{gn={"HalvedCube",n}},
Show[GraphData[gn]//StyleGraphs,PlotLabel->TextCell[Column[{Subscript[Style["H",Italic],n],Style[GraphData[gn,"Name"],Italic]},Alignment->Center],PageWidth->150,TextAlignment->Center],LabelStyle->Directive[12,Black,FontFamily->"Times"]]],{n,5}],Dividers->All,Alignment->Top,ImageSize->800]

Special Cases

ToEntity/@Table[HalvedCubeGraph[n],{n,10}]

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

The halved cube graph 1/2(Subscript[Q, 5]) is sometimes known as the Clebsch graph, and is the complement of the folded cube graph of order five which is more commonly called the Clebsch graph.

Embeddings

<<MathWorld`Graphs`

{"HalvedCube", 1} == "SingletonGraph"

Names

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

GraphData[{"HalvedCube",1},"StandardNames"]

{"HalvedCube", 2} == {"Path", 2}

Names

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

GraphData[{"HalvedCube",2},"StandardNames"]

{"HalvedCube", 3} == "TetrahedralGraph"

Names

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

GraphData[{"HalvedCube",3},"StandardNames"]

{"HalvedCube", 4} == "SixteenCellGraph"

Names

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

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

{"HalvedCube" ,5}

Names

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

GraphData[{"HalvedCube",5},"StandardNames"]

Primary

GraphData[{"HalvedCube",5}]//StyleGraphs[#,ImageSize->Small]&

All

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

Inexact

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

Embedding types

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

Default embedding

GraphPlot@RotateGraph[Graph[GraphData[{"HalvedCube",5},"Edges"]],{15,7}]

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

RecognizeGraph[g]

Degenerate

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

DegenerateGraphEmbeddingTypes/@GraphData[{"HalvedCube",5},"Graph","Degenerate"]

Complement

GraphData["ClebschGraph","Graph","All"]

GraphComplement/@%

gs=Take[%,5]

Perspective

GraphData[{"HalvedCube",5},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"HalvedCube",5},"Polyhedron"]

Bilateral

GraphData[{"HalvedCube",5},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"HalvedCube",5},"Graph","Circular"]//StyleGraphs

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"HalvedCube",5}],TimeConstraint->1])//AbsoluteTiming

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

(cn=CrossingNumber[GraphData[{"HalvedCube",5}],TimeConstraint->60])//AbsoluteTiming

(cn=CrossingNumber[GraphData[{"HalvedCube",5}],TimeConstraint->3600])//AbsoluteTiming

(g=MinimalCrossingGraph[GraphData[{"HalvedCube",5}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[g,"OuterFace"->#]&/@faces

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

Table[MinimalCrossingGraph[GraphData[{"HalvedCube",5}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HalvedCube",5},"Circulant"]

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

Line graph

GraphData[{"HalvedCube",5},"Line"]

LineGraphQ[GraphData[{"HalvedCube",5}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"HalvedCube",5}&]

RootGraph[GraphData[{"HalvedCube",5}]]

Halin

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

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

Rigid

GraphData[{"HalvedCube",5},"Rigid"]

GraphData[{"HalvedCube",5},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HalvedCube",5},"Flexible"]

GraphData[{"HalvedCube",5},"Graph","Flexible"]//StyleGraphs

LCF

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

GraphData[{"HalvedCube",5},"HamiltonianCycleCount"]

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

GraphData[{"HalvedCube",5},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"HalvedCube",5}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"HalvedCube",5}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"HalvedCube",5}],10^6])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

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

gs

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"HalvedCube",5}],10^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

LCF compute 5*^7

Tally[(lcf=LCF[GraphData[{"HalvedCube",5}],5*^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

l={{{"HalvedCube",5},{0,Missing["NotAvailable",{{{{-7,-6,-5,-4,-3,4,5,6},{-5,-4,-2,2,3,4,5,7}},8},{{{-7,-6,-4,-3,3,4,5,6},{-5,-4,-3,-2,2,3,4,7}},8},{{{-7,-5,-4,-3,-2,2,4,5},{-6,-5,-4,3,4,5,6,7}},8},{{{-7,-4,-3,-2,2,3,4,5},{-6,-5,-4,-3,3,4,6,7}},8}}]}}};

PropertyReplace[l,"LCFNotations","14.1"]

DeleteCases[lcf,{_,1|2}]

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

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

Length[gs]

gs

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"HalvedCube",5}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

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

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

UnitDistance

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

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

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"HalvedCube",5},"VertexList"],GraphData[{"HalvedCube",5},"EdgeList"]],MaxIterations->500]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"HalvedCube",5},"Graph",#]&/@{"All","UnitDistance"})

RotateGraph[,{9,6}]

UnitDistance by FindUnitDistanceEmbedding

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

RotateGraph[,{11,12}]

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

gs={,}

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"HalvedCube",  6}

Names

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

GraphData[{"HalvedCube",6},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

DegenerateGraphEmbeddingTypes/@GraphData[{"HalvedCube",6},"Graph","Degenerate"]

Perspective

GraphData[{"HalvedCube",6},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"HalvedCube",6},"Polyhedron"]

Bilateral

GraphData[{"HalvedCube",6},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

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

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

MinimalCrossing

GraphData[{"HalvedCube",6},{"RCN","CN"}]

GraphData[{"HalvedCube",6},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"HalvedCube",6}],TimeConstraint->1])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"HalvedCube",6}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[g,"OuterFace"->#]&/@faces

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

Table[MinimalCrossingGraph[GraphData[{"HalvedCube",6}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Line graph

GraphData[{"HalvedCube",6},"Line"]

LineGraphQ[GraphData[{"HalvedCube",6}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"HalvedCube",6}&]

RootGraph[GraphData[{"HalvedCube",6}]]

Halin

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

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

Rigid

GraphData[{"HalvedCube",6},"Rigid"]

GraphData[{"HalvedCube",6},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HalvedCube",6},"Flexible"]

GraphData[{"HalvedCube",6},"Graph","Flexible"]//StyleGraphs

LCF

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

GraphData[{"HalvedCube",6},"HamiltonianCycleCount"]

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

GraphData[{"HalvedCube",6},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"HalvedCube",6}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"HalvedCube",6}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 5*^5

Tally[(lcf=LCF[GraphData[{"HalvedCube",6}],5*^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"HalvedCube",6}],1*^6])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"HalvedCube",6}],1*^7])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"HalvedCube",6}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

UnitDistance

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

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

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

UnitDistance by refinement

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"HalvedCube",6},"Graph",#]&/@{"All","UnitDistance"})

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"HalvedCube", 7}

Names

GraphData[{"HalvedCube",7},"StandardName"]

GraphData[{"HalvedCube",7},"StandardNames"]

Primary

GraphData[{"HalvedCube",7}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"HalvedCube",7},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HalvedCube",7},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HalvedCube",7},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"HalvedCube",7},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"HalvedCube",7},"Graph","Degenerate"]

Perspective

GraphData[{"HalvedCube",7},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"HalvedCube",7},"Polyhedron"]

Bilateral

GraphData[{"HalvedCube",7},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"HalvedCube",7},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"HalvedCube",7},"Planar"]

GraphData[{"HalvedCube",7},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"HalvedCube",7},{"RCN","CN"}]

GraphData[{"HalvedCube",7},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"HalvedCube",7}],TimeConstraint->1])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"HalvedCube",7}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[g,"OuterFace"->#]&/@faces

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

Table[MinimalCrossingGraph[GraphData[{"HalvedCube",7}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HalvedCube",7},"Circulant"]

GraphData[{"HalvedCube",7},"Graph","Circulant"]//StyleGraphs

Line graph

GraphData[{"HalvedCube",7},"Line"]

LineGraphQ[GraphData[{"HalvedCube",7}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"HalvedCube",7}&]

RootGraph[GraphData[{"HalvedCube",7}]]

Halin

GraphData[{"HalvedCube",7},"Halin"]

GraphData[{"HalvedCube",7},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"HalvedCube",7},"Rigid"]

GraphData[{"HalvedCube",7},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HalvedCube",7},"Flexible"]

GraphData[{"HalvedCube",7},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"HalvedCube",7},"LCF"]

GraphData[{"HalvedCube",7},"HamiltonianCycleCount"]

GraphData[{"HalvedCube",7},"LCFSignature"]

GraphData[{"HalvedCube",7},"LCFNotations"]

GraphData[{"HalvedCube",7},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"HalvedCube",7}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"HalvedCube",7}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"HalvedCube",7}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

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

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

i=0;
gs={};
t0=AbsoluteTime[];
count=Length[order2];
Monitor[
Do[
If[!MissingQ[g=BilateralLCFGraph[LCFGraph@@order2[[i]]]],AppendTo[gs,g]],
{i,count}
],
Column[{
ProgressIndicator[i,{1,count}],
Row[{i,"/",count}],
Row[{"estimated time remaining: ",Round[(AbsoluteTime[]-t0) (count/i-1)]," s"}],
Row[{Length[gs]," bilateral graphs"}]
}]
];//Timing

UnitDistance

GraphData[{"HalvedCube",7},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"HalvedCube",7}],Debug->True]//Timing

GraphData[{"HalvedCube",7},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"HalvedCube",7},"VertexList"],GraphData[{"HalvedCube",7},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"HalvedCube",7},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"HalvedCube",7},"Matchstick"]

GraphData[{"HalvedCube",7},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"HalvedCube",7},"Edges"]]

3D All

GraphData[{"HalvedCube",7},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"HalvedCube",7},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"HalvedCube",7},"Polyhedral"]

GraphData[{"HalvedCube",7},"Graph",{"3D","Polyhedron"}]

{"HalvedCube",8}

Names

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

GraphData[{"HalvedCube",8},"StandardNames"]

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

DegenerateGraphEmbeddingTypes/@GraphData[{"HalvedCube",8},"Graph","Degenerate"]

Perspective

GraphData[{"HalvedCube",8},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"HalvedCube",8},"Polyhedron"]

Bilateral

GraphData[{"HalvedCube",8},"Graph","Bilateral"]//StyleGraphs

Circular

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

Planar

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

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

MinimalCrossing

GraphData[{"HalvedCube",8},{"RCN","CN"}]

GraphData[{"HalvedCube",8},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"HalvedCube",8}],TimeConstraint->1])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"HalvedCube",8}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[g,"OuterFace"->#]&/@faces

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

Table[MinimalCrossingGraph[GraphData[{"HalvedCube",8}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

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

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

Line graph

GraphData[{"HalvedCube",8},"Line"]

LineGraphQ[GraphData[{"HalvedCube",8}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"HalvedCube",8}&]

RootGraph[GraphData[{"HalvedCube",8}]]

Halin

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

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

Rigid

GraphData[{"HalvedCube",8},"Rigid"]

GraphData[{"HalvedCube",8},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HalvedCube",8},"Flexible"]

GraphData[{"HalvedCube",8},"Graph","Flexible"]//StyleGraphs

LCF

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

GraphData[{"HalvedCube",8},"HamiltonianCycleCount"]

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

GraphData[{"HalvedCube",8},"LCFNotations"]

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

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

LCF compute random

FindRandomLCFNotation[GraphData[{"HalvedCube",8}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"HalvedCube",8}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"HalvedCube",8}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

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

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

i=0;
gs={};
t0=AbsoluteTime[];
count=Length[order2];
Monitor[
Do[
If[!MissingQ[g=BilateralLCFGraph[LCFGraph@@order2[[i]]]],AppendTo[gs,g]],
{i,count}
],
Column[{
ProgressIndicator[i,{1,count}],
Row[{i,"/",count}],
Row[{"estimated time remaining: ",Round[(AbsoluteTime[]-t0) (count/i-1)]," s"}],
Row[{Length[gs]," bilateral graphs"}]
}]
];//Timing

UnitDistance

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

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

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"HalvedCube",8},"VertexList"],GraphData[{"HalvedCube",8},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"HalvedCube",8},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"HalvedCube",9}

Names

GraphData[{"HalvedCube",9},"StandardName"]

GraphData[{"HalvedCube",9},"StandardNames"]

Primary

GraphData[{"HalvedCube",9}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"HalvedCube",9},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HalvedCube",9},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HalvedCube",9},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"HalvedCube",9},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"HalvedCube",9},"Graph","Degenerate"]

Perspective

GraphData[{"HalvedCube",9},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"HalvedCube",9},"Polyhedron"]

Bilateral

GraphData[{"HalvedCube",9},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"HalvedCube",9},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"HalvedCube",9},"Planar"]

GraphData[{"HalvedCube",9},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"HalvedCube",9},{"RCN","CN"}]

GraphData[{"HalvedCube",9},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

(cn=CrossingNumber[GraphData[{"HalvedCube",9}],TimeConstraint->1])//AbsoluteTiming

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

(g=MinimalCrossingGraph[GraphData[{"HalvedCube",9}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[g,"OuterFace"->#]&/@faces

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

Table[MinimalCrossingGraph[GraphData[{"HalvedCube",9}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HalvedCube",9},"Circulant"]

GraphData[{"HalvedCube",9},"Graph","Circulant"]//StyleGraphs

Line graph

GraphData[{"HalvedCube",9},"Line"]

LineGraphQ[GraphData[{"HalvedCube",9}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"HalvedCube",9}&]

RootGraph[GraphData[{"HalvedCube",9}]]

Halin

GraphData[{"HalvedCube",9},"Halin"]

GraphData[{"HalvedCube",9},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"HalvedCube",9},"Rigid"]

GraphData[{"HalvedCube",9},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HalvedCube",9},"Flexible"]

GraphData[{"HalvedCube",9},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"HalvedCube",9},"LCF"]

GraphData[{"HalvedCube",9},"HamiltonianCycleCount"]

GraphData[{"HalvedCube",9},"LCFSignature"]

GraphData[{"HalvedCube",9},"LCFNotations"]

GraphData[{"HalvedCube",9},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"HalvedCube",9}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"HalvedCube",9}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"HalvedCube",9}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

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

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

i=0;
gs={};
t0=AbsoluteTime[];
count=Length[order2];
Monitor[
Do[
If[!MissingQ[g=BilateralLCFGraph[LCFGraph@@order2[[i]]]],AppendTo[gs,g]],
{i,count}
],
Column[{
ProgressIndicator[i,{1,count}],
Row[{i,"/",count}],
Row[{"estimated time remaining: ",Round[(AbsoluteTime[]-t0) (count/i-1)]," s"}],
Row[{Length[gs]," bilateral graphs"}]
}]
];//Timing

UnitDistance

GraphData[{"HalvedCube",9},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"HalvedCube",9}],Debug->True]//Timing

GraphData[{"HalvedCube",9},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"HalvedCube",9},"VertexList"],GraphData[{"HalvedCube",9},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"HalvedCube",9},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"HalvedCube",9},"Matchstick"]

GraphData[{"HalvedCube",9},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"HalvedCube",9},"Edges"]]

3D All

GraphData[{"HalvedCube",9},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"HalvedCube",9},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"HalvedCube",9},"Polyhedral"]

GraphData[{"HalvedCube",9},"Graph",{"3D","Polyhedron"}]

{"HalvedCube",10}

Names

GraphData[{"HalvedCube",10},"StandardName"]

GraphData[{"HalvedCube",10},"StandardNames"]

Primary

GraphData[{"HalvedCube",10}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"HalvedCube",10},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"HalvedCube",10},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"HalvedCube",10},"Edges"]

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

RecognizeGraph[g]

Degenerate

GraphData[{"HalvedCube",10},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"HalvedCube",10},"Graph","Degenerate"]

Perspective

GraphData[{"HalvedCube",10},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"HalvedCube",10},"Polyhedron"]

Bilateral

GraphData[{"HalvedCube",10},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"HalvedCube",10},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"HalvedCube",10},"Planar"]

GraphData[{"HalvedCube",10},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"HalvedCube",10},{"RCN","CN"}]

GraphData[{"HalvedCube",10},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

(g=MinimalCrossingGraph[GraphData[{"HalvedCube",10}],"CrossingNumber"->cn])//PolyhedralGraphQ

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

IGLayoutTutte[g,"OuterFace"->#]&/@faces

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

Table[MinimalCrossingGraph[GraphData[{"HalvedCube",10}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"HalvedCube",10},"Circulant"]

GraphData[{"HalvedCube",10},"Graph","Circulant"]//StyleGraphs

Line graph

GraphData[{"HalvedCube",10},"Line"]

LineGraphQ[GraphData[{"HalvedCube",10}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"HalvedCube",10}&]

RootGraph[GraphData[{"HalvedCube",10}]]

Halin

GraphData[{"HalvedCube",10},"Halin"]

GraphData[{"HalvedCube",10},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"HalvedCube",10},"Rigid"]

GraphData[{"HalvedCube",10},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"HalvedCube",10},"Flexible"]

GraphData[{"HalvedCube",10},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"HalvedCube",10},"LCF"]

GraphData[{"HalvedCube",10},"HamiltonianCycleCount"]

GraphData[{"HalvedCube",10},"LCFSignature"]

GraphData[{"HalvedCube",10},"LCFNotations"]

GraphData[{"HalvedCube",10},"Graph","LCF"]//StyleGraphs

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

LCF compute random

FindRandomLCFNotation[GraphData[{"HalvedCube",10}],TimeConstraint->120]

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"HalvedCube",10}],10^5])[[All,2]]]//Timing

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"HalvedCube",10}],All][[All,All,1]]]//Timing

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

MaxMemoryUsed[]/10.^9 "GB"

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

DeleteCases[lcf,{_,1}]

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

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

Length[gs]

gs

i=0;
gs={};
t0=AbsoluteTime[];
count=Length[order2];
Monitor[
Do[
If[!MissingQ[g=BilateralLCFGraph[LCFGraph@@order2[[i]]]],AppendTo[gs,g]],
{i,count}
],
Column[{
ProgressIndicator[i,{1,count}],
Row[{i,"/",count}],
Row[{"estimated time remaining: ",Round[(AbsoluteTime[]-t0) (count/i-1)]," s"}],
Row[{Length[gs]," bilateral graphs"}]
}]
];//Timing

UnitDistance

GraphData[{"HalvedCube",10},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"HalvedCube",10}],Debug->True]//Timing

GraphData[{"HalvedCube",10},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"HalvedCube",10},"VertexList"],GraphData[{"HalvedCube",10},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

UnitDistanceEmbeddingRefine[Annotate[#,VertexCoordinates->N[GraphEmbedding[#]]],MaxIterations->500]&/@Complement@@(GraphData[{"HalvedCube",10},"Graph",#]&/@{"All","UnitDistance"})

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"HalvedCube",10},"Matchstick"]

GraphData[{"HalvedCube",10},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"HalvedCube",10},"Edges"]]

3D All

GraphData[{"HalvedCube",10},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"HalvedCube",10},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"HalvedCube",10},"Polyhedral"]

GraphData[{"HalvedCube",10},"Graph",{"3D","Polyhedron"}]

Properties

Acyclic

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

AdjacencyMatrixCount

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

ArcTransitive

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

ArcTransitivity

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

AutomorphismCount

A288944

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

(seq=Table[GroupOrder[GraphAutomorphismGroup[HalvedCubeGraph[n]]],{n,10}])//Timing

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

(seq=Table[GroupOrder[GraphAutomorphismGroup[HalvedCubeGraph[n]]],{n,13}])//Timing

(seq=Table[GroupOrder[GraphAutomorphismGroup[HalvedCubeGraph[n]]],{n,14}])//Timing

(seq=Table[GroupOrder[GraphAutomorphismGroup[HalvedCubeGraph[n]]],{n,15,15}])//Timing

FindLinearRecurrence[seq]

FindLinearRecurrence[Rest@seq]

FindLinearRecurrence[Drop[seq,2]]

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

gf=x FindGeneratingFunction[seq,x]

BalabanIndex

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

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

FindSequenceFunction[Rest@seq,n-1]

Bandwidth

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

BridgeCount

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

BurningNumber

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

CharacteristicPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"CharacteristicPolynomial"],{n,k0=1,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[{"HalvedCube", n},"Chordal"],{n,10}]

ChordCount

Probably EdgeCount

Table[GraphData[{"HalvedCube", n},"EdgeCount"],{n,10}]

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

Chordless

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

ChordlessCycleCount

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

FindSequenceFunction[seq,n]

Chords

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

ChromaticallyUnique

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

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

ChromaticInvariant

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

FindSequenceFunction[DeleteMissing[seq],n]

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

ChromaticNumber

First 8 terms match A06238 but 9th term is <= 14

Pratt hasn't been able to find these either

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

Table[VertexChromaticNumber[GraphData[{"HalvedCube",n}]],{n,10}]//Timing

ChromaticPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"ChromaticPolynomial"],{n,k0=1,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[{"HalvedCube", n},"Circumference"],{n,10}]

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

Classes

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

CliqueCount

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

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

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

CliqueCoveringNumber

Possibly related A000983

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

FindSequenceFunction[{1,2,4,7,12,16,32},n]

CliqueNumber

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

CliquePolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"CliquePolynomial"],{n,k0=1,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]

CochromaticGraphNames

Table[GraphData[{"HalvedCube", n},"CochromaticGraphNames"],{n,10}]

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

ComplementOddChordlessCycleCount

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

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

ConnectedComponentCount

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

ConnectedDominatingSetCount

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

FindSequenceFunction[seq,n]

ConnectedDominationNumber

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

FindSequenceFunction[seq,n]

ConnectedDominationPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"ConnectedDominationPolynomial"],{n,k0=1,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

A288988

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

FindSequenceFunction[DeleteMissing[seq],n]

ConnectedInducedSubgraphPolynomial

Looks very amenable to cloded-form finfing

(poly=Factor[Table[GraphData[{"HalvedCube", n},"CharacteristicPolynomial"],{n,k0=1,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,10}]

FullSimplify[poly2-poly]

CrossingNumber

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

CycleCount

A234621

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

FindSequenceFunction[DeleteMissing[seq],n]

CyclePolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"CyclePolynomial"],{n,k0=1,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[{"HalvedCube", n},"Cyclic"],{n,10}]

CyclomaticNumber

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

FindSequenceFunction[seq,n]//FullSimplify

Factor[(-4+(-1+n) n)]

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

DetourIndex

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

FindSequenceFunction[seq,n]//FullSimplify

DetourMatrix

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

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

DetourPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"DetourPolynomial"],{n,k0=1,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,10}])//Column

Diameter

A004526

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

(seq=Table[GraphDiameter[HalvedCubeGraph[n]],{n,10}])//Timing

(seq=Table[GraphDiameter[HalvedCubeGraph[n]],{n,12}])//Timing

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

DistanceMatrix

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

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

DistancePolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"DistancePolynomial"],{n,k0=1,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[{"HalvedCube", n},"DistinguishingNumber"],{n,10}]

DomaticNumber

A290128

seq=Table[GraphData[{"HalvedCube",n},"DomaticNumber"],{n,10}]

From Stan Wagon, Jul 25 2017

You found 18 dominating sets. Their union is the 128 verts. Their lengths are  {7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7} (sum = 128)

Rob’s 18 dominating sets are below; they show that the domatic number of the Hamming-radius 2 graph on 7-length bits is exactly 18. I had found 17, and Rob started with one of my sets, and got the perfect example below.

And Weisstein and Velleman  (Eric: This of course applies to HalvedCube(8)).

Rob Pratt’s success is this list of 18 dominating sets for the Hamming-radius-2 graph (write in base 2 to see bits of course).

{0,18,47,57,84,107,111}
{1,58,60,71,79,118,120}
{2,31,35,42,77,89,116}
{3,7,11,12,112,125,126}
{4,20,43,68,91,117,122}
{5,39,56,67,90,94,101}
{6,53,55,73,88,98,108,123}
{8,32,63,65,86,87,104}
{9,14,30,49,81,102,121}
{10,24,40,50,69,119,127}
{13,23,37,61,80,82,106}
{15,25,26,36,92,96,100,115}
{16,21,52,59,78,99,105}
{17,19,34,76,95,109,124}
{22,29,54,62,72,75,97}
{27,38,44,64,85,110,113}
{28,41,45,66,83,103,114}
{33,46,48,51,70,74,93}

DominatingSetCount

A288986

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

FindSequenceFunction[DeleteMissing[seq],n]

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

DominationNumber

A029866

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

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

DominationPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"DominationPolynomial"],{n,k0=1,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[{"HalvedCube", n},"EdgeChromaticNumber"],{n,10}]

FindSequenceFunction[seq,n]

EdgeConnectivity

Table[GraphData[{"HalvedCube", n},"EdgeConnectivity"],{n,10}]

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

EdgeCount

Table[EdgeCount[HalvedCubeGraph[n]],{n,10}]

FindSequenceFunction[%,n]//FullSimplify

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

EdgeCoverCount

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

EdgeCoverNumber

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

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

EdgeCoverPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"EdgeCoverPolynomial"],{n,k0=1,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[{"HalvedCube", n},"EulerianCycleCount"],{n,10}]

FaceCount

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

FlowPolynomial

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

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

FractionalEdgeChromaticNumber

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

FindSequenceFunction[seq,n]

Girth

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

Gonality

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

HamiltonConnected

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

HamiltonDecompositionCount

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

Hamiltonian

Table[GraphData[{"HalvedCube", n},"Hamiltonian"],{n,10}]

HamiltonianCycleCount

A281255(n)/2

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

HamiltonianNumber

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

FindSequenceFunction[seq,n]

HamiltonianPathCount

A137888(n)/2

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

HamiltonianWalkCount

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

HararyIndex

A290347/A290348

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

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

(seq=Table[HararyIndex[HalvedCubeGraph[n]],{n,13}])//Timing

seq={0,1,6,26,100,(1096/3),(3920/3),(13936/3),16544,(296256/5),(1068672/5),(11652352/15),(42658304/15)};

FullSimplify[FindSequenceFunction[seq,n],n∈Integers&&n>1]

Table[-(2^(-2+n)) (I π+2 HarmonicNumber[n]+(2^(1+n)) LerchPhi[2,1,1+n]),{n,13}]//FullSimplify

FullSimplify[Re[-(2^(n-2)) (I π+2 HarmonicNumber[n]+(2^(n+1)) LerchPhi[2,1,1+n])],n∈Integers&&n>1]

seq=Table[-(2^(n-2)) (2 HarmonicNumber[n]+(2^(n+1))Re[LerchPhi[2,1,1+n]]),{n,40}]

Numerator[seq]

Denominator[seq]

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

Table[-(2^(n-1)) HarmonicNumber[n]-(2^(2n-1))Re[LerchPhi[2,1,n+1]],{n,20}]

HexagonCount

A290029

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

(seq=Monitor[Table[CycleCount[HalvedCubeGraph[n],6],{n,14}],n])//Timing

CycleCount[HalvedCubeGraph[15],6]//Timing

seq={0,0,0,640,34720,533760,4735360,30822400,164183040,759521280,3163607040,12148899840,43724595200,149243494400,487404503040};

FindSequenceFunction[seq,n]//Factor

(2^n)Binomial[n,4](81n^2-552n+952)

seq=Table[(2^n)Binomial[n,4](81n^2-552n+952),{n,30}]

coef=FindLinearRecurrence[seq]

Take[seq,Length[coef]]

LinearRecurrence[{14,-84,280,-560,672,-448,128},{0,0,0,640,34720,533760,4735360},20]

gf=x FindGeneratingFunction[seq,x]

ToString[gf,InputForm]

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

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

IdiosyncraticPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"IdiosyncraticPolynomial"],{n,k0=1,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

Conjectured to be equal to

A005864

1, 1, 1, 2, 2, 4, 8, 16, 20, 40, 72, 144, 256, 512, 1024, 2048

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

seq={1,1,1,2,2,4,8,16,20,40,72,144,256,512,1024,2048};

Do[Print[{n,FindIndependentVertexSet[HalvedCubeGraph[n]][[1]]//Length//Timing}],{n,10}]

IndependencePolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"IndependencePolynomial"],{n,k0=1,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[{"HalvedCube", n},"IndependenceRatio"],{n,10}]

FindSequenceFunction[seq,n]

IndependentEdgeSetCount

A290060

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

IndependentVertexSetCount

A288943

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

FindSequenceFunction[DeleteMissing@seq,n]

IntersectionNumber

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

KirchhoffIndex

A290365/A290366

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

Transpose[Through[{Numerator,Denominator}[#]]&/@seq]

Table[n!!,{n,1,13,2}]

seq={0,1,3,(25/3),(70/3),(3014/45),(2968/15),(63148/105),(197072/105),(9446128/1575),1232704/63,135120416/2079,151939840/693,47268893440/63063};

Numerator[seq]

Denominator[seq]

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

gf=x FindGeneratingFunction[seq,x]

seq2=seq Table[If[Mod[n,2]==0,(n-1)!!,n!!],{n,14}]

KirchhoffSumIndex

A290367/A290368

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

seq={0,1,3,(23/3),(115/6),(13123/270),(5698/45),(21445/63),(1190507/1260),(85183627/31500),25079197/3150,3749088082/155925,7720370957/103950};

Numerator[seq]

Denominator[seq]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n-1]

LaplacianMatrix

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

LaplacianPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

LeafCount

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

LongestCycleCount

===HamiltonianCycleCount

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

LovaszNumber

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

MatchingGeneratingPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"MatchingGeneratingPolynomial"],{n,k0=1,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[{"HalvedCube", n},"MatchingNumber"],{n,10}]

FindSequenceFunction[Rest@seq,n-1]

MatchingPolynomial

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

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

FindLinearRecurrence[seq]

FindLinearRecurrence[Drop[seq,3]]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

MaximalIndependentEdgeSetCount

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

MaximalIndependentVertexSetCount

A290606

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

MaximumCliqueCount

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

FindSequenceFunction[seq,n]

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

MaximumIndependentEdgeSetCount

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

MaximumIndependentVertexSetCount

A360685

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

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

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

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

Do[Print[{gn={"HalvedCube",n},MaximumIndependentVertexSetCount[HalvedCubeGraph[n]]//Timing}],{n,10}]

Table[With[{g=GraphPower[HypercubeGraph[n-1],2]},Length[FindIndependentVertexSet[g,Length/@FindIndependentVertexSet[g],All]]],{n,8}]

MaximumLeafNumber

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

MaximumVertexDegree

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

FindSequenceFunction[seq,n]

Binomial[n,2]

MeanDistance

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

FindSequenceFunction[Rest@seq,n-1]

MinimalDominatingSetCount

seq=Table[GraphData[{"HalvedCube",n},"MinimalDominatingSetCount"],{n,10}]

MinimumCliqueCoveringCount

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

MinimumConnectedDominatingSetCount

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

FindSequenceFunction[DeleteMissing@seq,n]

MinimumDistinguishingLabelingCount

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

MinimumDominatingSetCount

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

MinimumEdgeCoverCount

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

MinimumVertexDegree

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

FindSequenceFunction[seq,n]

Binomial[n,2]

MolecularTopologicalIndex

A192830

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

seq={0,4,72,672,4800,30240,178752,1017856,5640192,30528000,161694720,839393280,4277944320,21442011136,105877094400,515867934720,2483703250944,11831408197632,55825060331520,261152938393600,1212257811824640,5587829998485504};

coef=FindLinearRecurrence[seq]

RSolve[{a[n]==Sum[a[n-k]coef[[k]],{k,Length[coef]}],Sequence@@Table[a[k]==seq[[k]],{k,9}]},a[n],n]

FullSimplify[Subtract@@{2^(n-3)*n^2*(n-1)*(n-1+2^(n-2)),(2^(-5+n)) (-1+n) (n^2) (-4+(2^n)+4 n)}]

StringReplace[ToString[Sum[a["n-"<>ToString[k]]coef[[k]],{k,Length[coef]}],InputForm],{" "->"","\""->"","["->"(","]"->")"}]

FindSequenceFunction[seq,n]

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

Rest@CoefficientList[Series[-((4 (x^2) (1-8 x-4 (x^2)+224 (x^3)-744 (x^4)+576 (x^5)+480 (x^6)))/((((1-4 x))^4) (((-1+2 x))^5))),{x,0,10}],x]

StringReplace[ToString[gf,InputForm]," "->""]

Take[seq,9]

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

LinearRecurrence[{26,-296,1936,-8016,21792,-38912,44032,-28672,8192},{0,4,72,672,4800,30240,178752,1017856,5640192},20]

Nonhamiltonian

Table[GraphData[{"HalvedCube", n},"Nonhamiltonian"],{n,10}]

NormalizedLaplacianMatrix

MatrixForm/@Table[GraphData[{"HalvedCube", n},"NormalizedLaplacianMatrix"],{n,10}]

OddChordlessCycleCount

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

PathCount

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

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

PathPolynomial

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

A290028

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

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

FindSequenceFunction[seq,n]//Factor

3 (2^n)Binomial[n,4](29n-86)/5

seq=Table[3 (2^n)Binomial[n,4](29n-86)/5,{n,30}]

FindLinearRecurrence[seq]

LinearRecurrence[{12,-60,160,-240,192,-64},{0,0,0,288,5664,50688},20]

gf=x FindGeneratingFunction[seq,x]

ToString[gf,InputForm]

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

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

Perfect

Table[GraphData[{"HalvedCube", n},"Perfect"],{n,10}]

ProjectivePlaneCrossingNumber

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

Radius

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

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

RankPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"RankPolynomial"],{n,k0=1,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[{"HalvedCube", n},"RectilinearCrossingNumber"],{n,10}]

ReliabilityPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"ReliabilityPolynomial"],{n,k0=1,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[{"HalvedCube", n},"SigmaPolynomial"],{n,k0=1,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

A193135

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

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

SquareCount

A290027

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

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

FindSequenceFunction[seq,n]//Factor

3 (2^(n-5))Binomial[n,3](13n-35)

seq=Table[3 (2^(n-5))Binomial[n,3](13n-35),{n,30}]

FindLinearRecurrence[seq]

LinearRecurrence[{10,-40,80,-80,32},{0,0,3,102,900},20]

gf=x FindGeneratingFunction[seq,x]

ToString[gf,InputForm]

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

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

StabilityIndex

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

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

TopologicalIndex

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

FindSequenceFunction[seq,n]

FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

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

Traceable

Table[GraphData[{"HalvedCube", n},"Traceable"],{n,10}]

TriangleCount

A290026

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

(seq=Monitor[Table[CycleCount[HalvedCubeGraph[n],3],{n,12}],n])//Timing

FindSequenceFunction[seq,n]//FullSimplify

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

FindLinearRecurrence[seq]

LinearRecurrence[{8,-24,32,-16},{0,0,4,32},20]

gf=x FindGeneratingFunction[seq,x]

ToString[gf,InputForm]

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

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

TuttePolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"TuttePolynomial"],{n,k0=1,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[{"HalvedCube", n},"Untraceable"],{n,10}]

VertexConnectivity

seq=Table[GraphData[{"HalvedCube", n},"VertexConnectivity"],{n,10}]

FindSequenceFunction[seq,n]

Binomial[n,2]

VertexCount

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

FindSequenceFunction[seq,n]

VertexCoverNumber

vertex cover number == vertex count - independence number

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

FindSequenceFunction[seq,n]//FullSimplify

gf=x FindGeneratingFunction[seq,x]

VertexCoverPolynomial

(poly=Factor[Table[GraphData[{"HalvedCube", n},"VertexCoverPolynomial"],{n,k0=1,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[{"HalvedCube", n},"VertexDegrees"],{n,5}]

VertexTransitive

Table[GraphData[{"HalvedCube", n},"VertexTransitive"],{n,10}]

WienerIndex

A292044

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

FindSequenceFunction[Take[l,9]][n]

FindSequenceFunction[Take[l,{2,9}]][n-1]//Simplify

seq=Table[If[n==1,0,(2^(2 n-5)) n],{n,40}]

FindLinearRecurrence[Rest@seq]

Join[{0},LinearRecurrence[{8,-16},{1,6},20]]

gf=x FindGeneratingFunction[seq,x]

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

WienerSumIndex

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

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

Construction

GraphPower

RecognizeGraph/@Table[GraphPower[HypercubeGraph[n-1],2],{n,6}]

DistanceGraph

HalvedCubeGraph[1,opts___?OptionQ]:=System`Graph[{1},{},opts]
HalvedCubeGraph[n_Integer?Positive,opts___?OptionQ]:=Module[{dg=DistanceGraph[HypercubeGraph[n],2]},SetProperty[IndexGraph[VertexDelete[dg,ConnectedComponents[dg][[1]]]],{opts}]]

HammingDistance2

Code modified from Stan Wagon, Jul. 15, 2017

?HammingDistance

HammingDistanceGraph[n_,k_]:=Module[{dom=Tuples[{0,1},{n}]},edges=Select[Flatten[Table[{i,j},{i,2^n},{j,i,2^n}],1],0<HammingDistance@@dom[[#]]≤k&];
System`Graph[Range[2^n],Apply[UndirectedEdge,edges,{1}]]];

RecognizeGraph/@Table[HammingDistanceGraph[n-1,2],{n,5}]

GraphData

GraphClassString

GraphData["HalvedCube"]

GraphClassString[GraphData["HalvedCube"]]

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

GraphDataString

file=OpenWrite["halfcube.m"]

Row[{Subscript["D",Row[{n,",",n}]],"(","1",")"}]//TraditionalForm

Do[WriteString[file,GraphDataString[HalvedCube[n],
"StandardName"->{"HalvedCube",n},
"Name"->"halved "<>ToString[n]<>"-cube",
"Information"->"HalvedCubeGraph",
"Classes"->{"HalvedCube"},
"NotationRules"->{"HalvedCube"->n},
"Notation"->Row[{Subscript["D",Row[{n,",",n}]],"(","1",")"}],
Debug->True,
TimeConstraint->30
]],{n,5,10}];

Close[file]