Crossed Prism Graph

Author

Eric W. Weisstein
March 1, 2024

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

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

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

Graphics

Graphs.m

GraphicsGrid[Partition[Table[CrossedPrism[2n]//StyleGraphs,{n,2,10}],5],Dividers->All]

GraphData

GraphicsGrid[Partition[Show[GraphData[#]//StyleGraphs,PlotLabel->TextCell[Style[GraphData[#,"Name"],Directive[Black,FontFamily->"Times",14]],PageWidth->100,TextAlignment->Center,Italic]]&/@SortBy[GraphData["CrossedPrism"],GraphData[#,"V"]&],UpTo[4]],Dividers->All,ImageSize->600]

CrossedPrismGraph[2 n] == HoneycombToroidalGraph[1, 4 n, 2 n - 1]

IsomorphicGraphQ@@@Table[{CrossedPrismGraph[2n],HoneycombToroidalGraph[1,4n,2n-1]},{n,3,30}]//Union

Table[{"HoneycombToroidal",{1,4n,2n-1}},{n,11,20}]

Intersection[%,GraphData[All]]

CubicVertexTransitive

Cases[
Table[{n,GraphData[RecognizeGraph[CubicVertexTransitiveGraph[n]],"NotationRules","CrossedPrism"]},{n,7,1000}]//Quiet,
{_,_Integer}]

Embeddings

<<MathWorld`Graphs`

GraphData["CrossedPrism"]

{"CrossedPrism", 4} == "CubicalGraph"

Names

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

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

{"CrossedPrism", 6} == "FranklinGraph"

Names

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

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

{"CrossedPrism", 8}

Names

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

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

Primary

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

Read and Wilson

All

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

Inexact

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

Inexact

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

Embedding types

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

Default embedding

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

CrossedPrismGraph[8,"Radii"->{1,2},VertexLabels->Automatic]

v=GraphEmbedding[%];

((v[[14,2]])/(v[[5,2]]))

g=CrossedPrismGraph[8,"Radii"->{2 Tan[(π/8)],2},VertexLabels->Automatic]

RecognizeGraph[g]

g=CrossedPrismGraph[8]

Degenerate

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

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

Perspective

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

Perspective construction

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

HoneycombToroidal construction

GraphData[{"CrossedPrism",8},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,16,7]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=16},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",8}}]]//Timing

g=GeneralizedHoneycombGraph[16,7]

RecognizeGraph@g

CrossedPrismGraph[8,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphPlot@

v={#/2,#2/3}&@@@{{0,0},{0,1},{-1,2},{0,2},{1,2},{-2,3},{0,3},{2,3},{-1,4},{0,4},{1,4},{-2,5},{0,5},{2,5},{0,6},{0,7}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,8,14,16,12,6,1,2,5,4,3,2],e[6,7,8],e[12,13,14],e[9,10,11,15,9,3],{4,7},{5,11},{10,13},{15,16}},VertexCoordinates->v,VertexLabels->Automatic]

v={{0,0},{0,1},{-1,2},{0,2},{1,2},{-3,3},{0,3},{3,3},{-1,4},{0,4},{1,4},{-3,5},{0,5},{3,5},{0,6},{0,7}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,8,14,16,12,6,1,2,5,4,3,2],e[6,7,8],e[12,13,14],e[9,10,11,15,9,3],{4,7},{5,11},{10,13},{15,16}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@RotateGraph[,Pi/8]

v=CirclePoints[8];

p1=RegionIntersection[Line[v[[{8,3}]]],Line[v[[{2,5}]]]][[1,1]]//FullSimplify

p2=RegionIntersection[Line[v[[{8,3}]]],Line[v[[{1,6}]]]][[1,1]]//FunctionExpand//FullSimplify

s=1/5;
v=Join[v,
Sequence@@Table[{i,1}#&/@{p1+Normalize[v[[8]]-v[[3]]]s,p1+Normalize[v[[2]]-v[[5]]]s},{i,{-1,1}}],{p2+Normalize[v[[1]]-v[[6]]]s,p2+Normalize[v[[8]]-v[[3]]]s},
{-p2+Normalize[v[[7]]-v[[4]]]s,-p2+Normalize[v[[2]]-v[[5]]]s}
];
g=Graph[Range@Length@v,UndirectedEdge@@@{e[1,2,3,4,5,6,7,8,1,13,9,6],e[7,10,15,4],e[8,14,11,3],e[5,16,12,2],{13,14},{11,12},{15,16},{9,10}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph@g

GraphPlot@RotateGraph[,Pi/8]

v={#/5,#2/4}&@@@{{0,0},{5,0},{0,1},{1,1},{2,1},{3,1},{4,1},{5,1},{0,2},{2,2},{3,2},{5,2},{1,3},{4,3},{0,4},{5,4}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,2,8,12,16,15,9,3,1,5,11,12],e[9,10,6,2],{5,6},e[15,14,13,16],e[3,4,10],e[11,7,8],{4,13},{7,14}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

GraphPlot@

v={{0,0},{0,1},{-1,2},{0,2},{1,2},{-3,3},{0,3},{3,3},{-3,4},{0,4},{3,4},{-1,5},{0,5},{1,5},{0,6},{0,7}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,8,11,16,9,6,1,2,5,4,3,2],e[6,7,8],e[9,10,11],{4,7},e[16,15,14,13,12,15],{3,12},{5,14},{10,13}},VertexCoordinates->v,VertexLabels->Automatic]

RecognizeGraph[g]

RectilinearCrossingCount[g]

v={{0,0},{0,1},{-1,2},{0,2},{1,2},{-3,3},{0,3},{3,3},{-3,4},{0,4},{3,4},{-1,5},{0,5},{1,5},{0,6},{0,7}};
g=Graph[Range[Length[v]],UndirectedEdge@@@{e[1,8,11,16,9,6,1,2,5,4,3,2],e[6,7,8],e[9,10,11],{4,7},e[16,15,14,13,12,15],{3,12},{5,14},{10,13}},VertexCoordinates->v,VertexLabels->Automatic]

v0=(g0=)//GraphEmbedding

v={#/7,#2/3}&@@@v0;
g=Annotate[g0,VertexCoordinates->v]

gs=UnlabelGraph/@{,,,,}

gs=UnlabelGraph/@{,}

Circulant

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

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

Complement graph

GraphData[{"CrossedPrism",8},"ComplementGraph","Name"]

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

Divisors[GraphData[{"CrossedPrism",8},"V"]]

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

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

lcf

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

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

UnitDistanceGraphQ[GraphData[{"CrossedPrism",8}],Debug->True]

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

FindUnitDistanceEmbedding

Select[FindUnitDistanceEmbedding[GraphData[{"CrossedPrism",8}],50],UnitDistanceGraphEmbeddingQ]

l=FindSubgraphIsomorphism[GraphData[{"CrossedPrism",8}],"Results"->All]//Timing

gs=UniqueEmbeddings[l]

gs=CenterGraph/@IndexGraph/@LabelGraph/@{,RotateGraph[,{126,116}]}

Matchstick

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"CrossedPrism", 10}

Names

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

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

Primary

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

Read and Wilson

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

g=CrossedPrismGraph[10,VertexLabels->Automatic]

RecognizeGraph[g]

v=Join[CirclePoints[10],CirclePoints[3/4,10]];
g=Graph[Range@Length@v,UndirectedEdge@@@{},VertexCoordinates->v,VertexLabels->Automatic]

Degenerate

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

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

HoneycombToroidal construction

GraphData[{"CrossedPrism",10},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,20,9]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=20},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",10}}]]//Timing

gs=GeneralizedHoneycombGraph[20,#]&/@{5,9}

RecognizeGraph/@gs

CrossedPrismGraph[10,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

Table[MinimalCrossingGraph[GraphData[{"CrossedPrism",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[{"CrossedPrism",10},"Circulant"]

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

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute all

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

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

lcf

LCFGraph@@@lcf//StyleGraphs

(gs=Flatten[{
(* all LCF's with order >1, sorted by order and with bilateral graphs first *)
Join[DeleteCases[#,{_Missing,_}][[All,1]],Cases[#,{_Missing,_}][[All,2]]]&/@Map[{BilateralLCFGraph@#,#}&,Map[LCFGraph@@#&,SplitBy[DeleteCases[lcf,{_,1}],Last],{2}],{2}],
(* order-1 bilateral only *)
DeleteMissing[BilateralLCFGraph@@@Cases[lcf,{_,1}]]}])//Timing

Length[gs]

UnitDistance

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

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

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

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

UnitDistance by refinement

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

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

UnitDistance construction

LabelGraph[GraphicsToGraph@]

Clear[e,h];
v={
(*1*){e+1,f},{x,-y},{d,0},{a,b},
(*5*){g,h},{g+1,h},{-a,b},{-d,0},{-x,-y},
(*10*){e,f},{-(e+1),-f},{x,y},{-c,0},{-a,-b},
(*15*){-g,-h},{-(g+1),-h},{a,-b},{c,0},{-x,y},
(*20*){-e,-f}};
ee=GraphData[{"CrossedPrism",10},"Edges"];
eqn=UnitEdgeEquations[v,ee]//FullSimplify//Union

var=Variables[Subtract@@@eqn]

Length/@{eqn,var}

soln=Solve[eqn,var,Reals]

gs=Graph[Range[Length[v]],ee,VertexCoordinates->(v/.#)]&/@soln

Select[%,UnitDistanceGraphEmbeddingQ]

Clear[e,h];
v={
(*1*){e+1,f},{x,-y},{c,i},{a,b},
(*5*){g,h},{g+1,h},{-a,b},{-d,i},{-x,-y},
(*10*){e,f},{-(e+1),-f},{x,y},{-c,j},{-a,-b},
(*15*){-g,-h},{-(g+1),-h},{a,-b},{d,j},{-x,y},
(*20*){-e,-f}};
ee=GraphData[{"CrossedPrism",10},"Edges"];
eqn=UnitEdgeEquations[v,ee]//FullSimplify//Union

var=Variables[Subtract@@@eqn]

Length/@{eqn,var}

soln=Solve[eqn,var,Reals]

Select[Graph[Range[Length[v]],ee,VertexCoordinates->(v/.#)]&/@soln,UnitDistanceGraphEmbeddingQ]

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

{"CrossedPrism", 12}

Names

GraphData[{"CrossedPrism",12},"StandardName"]

GraphData[{"CrossedPrism",12},"StandardNames"]

Primary

GraphData[{"CrossedPrism",12}]//StyleGraphs[#,ImageSize->Small]&

Read and Wilson

All

GraphData[{"CrossedPrism",12},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"CrossedPrism",12},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"CrossedPrism",12},"Edges"]

g=CrossedPrismGraph[12,VertexLabels->Automatic]

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

RecognizeGraph[g]

Degenerate

GraphData[{"CrossedPrism",12},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"CrossedPrism",12},"Graph","Degenerate"]

HoneycombToroidal construction

GraphData[{"CrossedPrism",12},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,24,11]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=24},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",12}}]]//Timing

g=GeneralizedHoneycombGraph[24,11]

RecognizeGraph@g

CrossedPrismGraph[24,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

GraphData[{"CrossedPrism",12},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"CrossedPrism",12},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"CrossedPrism",12},"Planar"]

GraphData[{"CrossedPrism",12},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",12},{"RCN","CN"}]

GraphData[{"CrossedPrism",12},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

GraphPlot[RotateGraph[,2Pi/6],VertexSize->1]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"CrossedPrism",12},"Circulant"]

GraphData[{"CrossedPrism",12},"Graph","Circulant"]//StyleGraphs

Line graph

GraphData[{"CrossedPrism",12},"Line"]

LineGraphQ[GraphData[{"CrossedPrism",12}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"CrossedPrism",12}&]

RootGraph[GraphData[{"CrossedPrism",12}]]

Halin

GraphData[{"CrossedPrism",12},"Halin"]

GraphData[{"CrossedPrism",12},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"CrossedPrism",12},"Rigid"]

GraphData[{"CrossedPrism",12},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"CrossedPrism",12},"Flexible"]

GraphData[{"CrossedPrism",12},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"CrossedPrism",12},"LCF"]

GraphData[{"CrossedPrism",12},"HamiltonianCycleCount"]

GraphData[{"CrossedPrism",12},"LCFSignature"]

GraphData[{"CrossedPrism",12},"LCFNotations"]

GraphData[{"CrossedPrism",12},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"CrossedPrism",12}],All][[All,All,1]]]//Timing

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

lcf

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"CrossedPrism",12},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"CrossedPrism",12}],Debug->True]//Timing

GraphData[{"CrossedPrism",12},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"CrossedPrism",12},"VertexList"],GraphData[{"CrossedPrism",12},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

gs={,,,,};

Matchstick

GraphData[{"CrossedPrism",12},"Matchstick"]

GraphData[{"CrossedPrism",12},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"CrossedPrism",12},"Edges"]]

3D All

GraphData[{"CrossedPrism",12},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"CrossedPrism",12},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"CrossedPrism",12},"Polyhedral"]

{"CrossedPrism", 14}

Names

GraphData[{"CrossedPrism",14},"StandardName"]

GraphData[{"CrossedPrism",14},"StandardNames"]

Primary

GraphData[{"CrossedPrism",14}]//StyleGraphs[#,ImageSize->Small]&

Read and Wilson

All

GraphData[{"CrossedPrism",14},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"CrossedPrism",14},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"CrossedPrism",14},"Edges"]

g=CrossedPrismGraph[14,VertexLabels->Automatic]

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

RecognizeGraph[g]

Degenerate

GraphData[{"CrossedPrism",14},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"CrossedPrism",14},"Graph","Degenerate"]

HoneycombToroidal construction

GraphData[{"CrossedPrism",14},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,28,13]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=28},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",14}}]]//Timing

gs=GeneralizedHoneycombGraph[28,#]&/@{7,13}

RecognizeGraph/@gs

CrossedPrismGraph[14,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

GraphData[{"CrossedPrism",14},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"CrossedPrism",14},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"CrossedPrism",14},"Planar"]

GraphData[{"CrossedPrism",14},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",14},{"RCN","CN"}]

GraphData[{"CrossedPrism",14},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"CrossedPrism",14},"Circulant"]

GraphData[{"CrossedPrism",14},"Graph","Circulant"]//StyleGraphs

Line graph

GraphData[{"CrossedPrism",14},"Line"]

LineGraphQ[GraphData[{"CrossedPrism",14}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"CrossedPrism",14}&]

RootGraph[GraphData[{"CrossedPrism",14}]]

Halin

GraphData[{"CrossedPrism",14},"Halin"]

GraphData[{"CrossedPrism",14},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"CrossedPrism",14},"Rigid"]

GraphData[{"CrossedPrism",14},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"CrossedPrism",14},"Flexible"]

GraphData[{"CrossedPrism",14},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"CrossedPrism",14},"LCF"]

GraphData[{"CrossedPrism",14},"HamiltonianCycleCount"]

GraphData[{"CrossedPrism",14},"LCFSignature"]

GraphData[{"CrossedPrism",14},"LCFNotations"]

GraphData[{"CrossedPrism",14},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Length[FindHamiltonianCycle[GraphData[{"CrossedPrism",14}],All][[All,All,1]]]//Timing

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

lcf

lcf

LCFGraph@@@lcf//StyleGraphs

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"CrossedPrism",14},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"CrossedPrism",14}],Debug->True]//Timing

GraphData[{"CrossedPrism",14},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"CrossedPrism",14},"VertexList"],GraphData[{"CrossedPrism",14},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

UnitDistance by FindSubgraphUnitDistanceEmbedding

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

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

Matchstick

GraphData[{"CrossedPrism",14},"Matchstick"]

GraphData[{"CrossedPrism",14},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"CrossedPrism",14},"Edges"]]

3D All

GraphData[{"CrossedPrism",14},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"CrossedPrism",14},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"CrossedPrism",14},"Polyhedral"]

{"CrossedPrism", 16}

Names

GraphData[{"CrossedPrism",16},"StandardName"]

GraphData[{"CrossedPrism",16},"StandardNames"]

Primary

GraphData[{"CrossedPrism",16}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"CrossedPrism",16},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"CrossedPrism",16},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"CrossedPrism",16},"Edges"]

g=CrossedPrismGraph[16]

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

RecognizeGraph[g]

Degenerate

GraphData[{"CrossedPrism",16},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"CrossedPrism",16},"Graph","Degenerate"]

Perspective

GraphData[{"CrossedPrism",16},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"CrossedPrism",16},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"CrossedPrism",16},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[32,15]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=32},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",16}}]]//Timing

g=GeneralizedHoneycombGraph[32,15]

RecognizeGraph@g

CrossedPrismGraph[16,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

GraphData[{"CrossedPrism",16},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"CrossedPrism",16},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"CrossedPrism",16},"Planar"]

GraphData[{"CrossedPrism",16},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",16},{"RCN","CN"}]

GraphData[{"CrossedPrism",16},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"CrossedPrism",16},"Circulant"]

GraphData[{"CrossedPrism",16},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"CrossedPrism",16},"ComplementGraph","Name"]

Line graph

GraphData[{"CrossedPrism",16},"Line"]

LineGraphQ[GraphData[{"CrossedPrism",16}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"CrossedPrism",16}&]

RootGraph[GraphData[{"CrossedPrism",16}]]

Halin

GraphData[{"CrossedPrism",16},"Halin"]

GraphData[{"CrossedPrism",16},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"CrossedPrism",16},"Rigid"]

GraphData[{"CrossedPrism",16},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"CrossedPrism",16},"Flexible"]

GraphData[{"CrossedPrism",16},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"CrossedPrism",16},"LCF"]

GraphData[{"CrossedPrism",16},"HamiltonianCycleCount"]

GraphData[{"CrossedPrism",16},"LCFSignature"]

GraphData[{"CrossedPrism",16},"LCFNotations"]

GraphData[{"CrossedPrism",16},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"CrossedPrism",16},"V"]]

Length[FindHamiltonianCycle[GraphData[{"CrossedPrism",16}],All][[All,All,1]]]//Timing

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

lcf

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@%

UnitDistance

GraphData[{"CrossedPrism",16},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"CrossedPrism",16}],Debug->True]//Timing

GraphData[{"CrossedPrism",16},"Graph","UnitDistance"]//StyleGraphs

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"CrossedPrism",16},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

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

FindSubgraphUnitDistanceEmbedding[GraphData[{"CrossedPrism",16}],"Results"->All]//Timing

gs={,};

gs=UniqueEmbeddings[l]

gs={,,,,,,,,};

Matchstick

GraphData[{"CrossedPrism",16},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"CrossedPrism",16},"Edges"]]

3D All

GraphData[{"CrossedPrism",16},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"CrossedPrism",16},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"CrossedPrism",16},"Graph",{"3D","Polyhedron"}]

{"CrossedPrism", 18}

Names

GraphData[{"CrossedPrism",18},"StandardName"]

GraphData[{"CrossedPrism",18},"StandardNames"]

Primary

GraphData[{"CrossedPrism",18}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"CrossedPrism",18},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"CrossedPrism",18},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"CrossedPrism",18},"Edges"]

g=CrossedPrismGraph[18]

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

RecognizeGraph[g]

Degenerate

GraphData[{"CrossedPrism",18},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"CrossedPrism",18},"Graph","Degenerate"]

Perspective

GraphData[{"CrossedPrism",18},"Graph","Perspective"]//StyleGraphs

Perspective construction

PolyhedronGraph[GraphData[{"CrossedPrism",18},"Polyhedron"]]

HoneycombToroidal construction

GraphData[{"CrossedPrism",18},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,36,17]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=36},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",18}}]]//Timing

gs=GeneralizedHoneycombGraph[36,#]&/@{9,17}

RecognizeGraph/@gs

CrossedPrismGraph[18,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

GraphData[{"CrossedPrism",18},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"CrossedPrism",18},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"CrossedPrism",18},"Planar"]

GraphData[{"CrossedPrism",18},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",18},{"RCN","CN"}]

GraphData[{"CrossedPrism",18},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"CrossedPrism",18},"Circulant"]

Complement graph

GraphData[{"CrossedPrism",18},"ComplementGraph","Name"]

Line graph

GraphData[{"CrossedPrism",18},"Line"]

LineGraphQ[GraphData[{"CrossedPrism",18}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"CrossedPrism",18}&]

RootGraph[GraphData[{"CrossedPrism",18}]]

Halin

GraphData[{"CrossedPrism",18},"Halin"]

GraphData[{"CrossedPrism",18},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"CrossedPrism",18},"Rigid"]

GraphData[{"CrossedPrism",18},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"CrossedPrism",18},"Flexible"]

GraphData[{"CrossedPrism",18},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"CrossedPrism",18},"LCF"]

GraphData[{"CrossedPrism",18},"HamiltonianCycleCount"]

GraphData[{"CrossedPrism",18},"LCFSignature"]

GraphData[{"CrossedPrism",18},"LCFNotations"]

GraphData[{"CrossedPrism",18},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"CrossedPrism",18},"V"]]

Length[FindHamiltonianCycle[GraphData[{"CrossedPrism",18}],All][[All,All,1]]]//Timing

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

lcf

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

UnitDistance

GraphData[{"CrossedPrism",18},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"CrossedPrism",18}],Debug->True]//Timing

GraphData[{"CrossedPrism",18},"Graph","UnitDistance"]//StyleGraphs

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

Select[UnitDistanceEmbeddingRefine/@Complement@@(GraphData[{"CrossedPrism",18},"Graph",#]&/@{"All","UnitDistance"}),UnitDistanceGraphEmbeddingQ]

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

UnitDistance FindSubgraphUnitDistanceEmbedding

{{"CrossedPrism",18},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"CrossedPrism",18}],TimeConstraint->3600,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"CrossedPrism",18},"Graph","Matchstick"]//StyleGraphs

3D default

Graph3D[GraphData[{"CrossedPrism",18},"Edges"]]

3D All

GraphData[{"CrossedPrism",18},"Graph",{"3D","All"}]

3D UnitDistance

GraphData[{"CrossedPrism",18},"Graph",{"3D","UnitDistance"}]

3D Polyhedron

GraphData[{"CrossedPrism",18},"Graph",{"3D","Polyhedron"}]

{"CrossedPrism", 20}

Names

GraphData[{"CrossedPrism",20},"StandardName"]

GraphData[{"CrossedPrism",20},"StandardNames"]

Primary

GraphData[{"CrossedPrism",20}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"CrossedPrism",20},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"CrossedPrism",20},"EdgeList"]]

Default embedding

GraphPlot@GraphData[{"CrossedPrism",20},"Edges"]

g=CrossedPrismGraph[20]

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

RecognizeGraph[g]

Degenerate

GraphData[{"CrossedPrism",20},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"CrossedPrism",20},"Graph","Degenerate"]

Perspective

GraphData[{"CrossedPrism",20},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"CrossedPrism",20},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"CrossedPrism",20},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,40,19]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=40},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",20}}]]//Timing

g=GeneralizedHoneycombGraph[40,19]

RecognizeGraph@g

CrossedPrismGraph[20,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

GraphData[{"CrossedPrism",20},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"CrossedPrism",20},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"CrossedPrism",20},"Planar"]

GraphData[{"CrossedPrism",20},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",20},{"RCN","CN"}]

GraphData[{"CrossedPrism",20},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"CrossedPrism",20},"Circulant"]

GraphData[{"CrossedPrism",20},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"CrossedPrism",20},"ComplementGraph","Name"]

Line graph

GraphData[{"CrossedPrism",20},"Line"]

LineGraphQ[GraphData[{"CrossedPrism",20}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"CrossedPrism",20}&]

RootGraph[GraphData[{"CrossedPrism",20}]]

Halin

GraphData[{"CrossedPrism",20},"Halin"]

GraphData[{"CrossedPrism",20},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"CrossedPrism",20},"Rigid"]

GraphData[{"CrossedPrism",20},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"CrossedPrism",20},"Flexible"]

GraphData[{"CrossedPrism",20},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"CrossedPrism",20},"LCF"]

GraphData[{"CrossedPrism",20},"HamiltonianCycleCount"]

GraphData[{"CrossedPrism",20},"LCFSignature"]

GraphData[{"CrossedPrism",20},"LCFNotations"]

GraphData[{"CrossedPrism",20},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"CrossedPrism",20},"V"]]

Length[FindHamiltonianCycle[GraphData[{"CrossedPrism",20}],All][[All,All,1]]]//Timing

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

lcf

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@%

UnitDistance

GraphData[{"CrossedPrism",20},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"CrossedPrism",20}],Debug->True]

GraphData[{"CrossedPrism",20},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"CrossedPrism",20},"VertexList"],GraphData[{"CrossedPrism",20},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

FindSubgraphIsomorphism

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

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

gs={,,};

Matchstick

GraphData[{"CrossedPrism",20},"Graph","Matchstick"]//StyleGraphs

{"CrossedPrism", 22}

Names

GraphData[{"CrossedPrism",22},"StandardName"]

GraphData[{"CrossedPrism",22},"StandardNames"]

Primary

GraphData[{"CrossedPrism",22}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"CrossedPrism",22},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"CrossedPrism",22},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"CrossedPrism",22},"Edges"]

g=CrossedPrismGraph[22]

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

RecognizeGraph[g]

Degenerate

GraphData[{"CrossedPrism",22},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"CrossedPrism",22},"Graph","Degenerate"]

Perspective

GraphData[{"CrossedPrism",22},"Graph","Perspective"]//StyleGraphs

Perspective construction

GraphData[{"CrossedPrism",22},"Polyhedron"]

HoneycombToroidal construction

GraphData[{"CrossedPrism",22},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,44,21]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=44},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",22}}]]//Timing

gs=GeneralizedHoneycombGraph[44,#]&/@{11,21}

RecognizeGraph/@gs

CrossedPrismGraph[22,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

GraphData[{"CrossedPrism",22},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"CrossedPrism",22},"Graph","Circular"]//StyleGraphs

Planar

GraphData[{"CrossedPrism",22},"Planar"]

GraphData[{"CrossedPrism",22},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",22},{"RCN","CN"}]

GraphData[{"CrossedPrism",22},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"CrossedPrism",22},"Circulant"]

GraphData[{"CrossedPrism",22},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"CrossedPrism",22},"ComplementGraph","Name"]

Line graph

GraphData[{"CrossedPrism",22},"Line"]

LineGraphQ[GraphData[{"CrossedPrism",22}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"CrossedPrism",22}&]

RootGraph[GraphData[{"CrossedPrism",22}]]

Halin

GraphData[{"CrossedPrism",22},"Halin"]

GraphData[{"CrossedPrism",22},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"CrossedPrism",22},"Rigid"]

GraphData[{"CrossedPrism",22},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"CrossedPrism",22},"Flexible"]

GraphData[{"CrossedPrism",22},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"CrossedPrism",22},"LCF"]

GraphData[{"CrossedPrism",22},"HamiltonianCycleCount"]

GraphData[{"CrossedPrism",22},"LCFSignature"]

GraphData[{"CrossedPrism",22},"LCFNotations"]

GraphData[{"CrossedPrism",22},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"CrossedPrism",22},"V"]]

Length[FindHamiltonianCycle[GraphData[{"CrossedPrism",22}],All][[All,All,1]]]//Timing

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

DeleteCases[lcf,{_,1}]

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@%

UnitDistance

GraphData[{"CrossedPrism",22},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"CrossedPrism",22}],Debug->True]//Timing

GraphData[{"CrossedPrism",22},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"CrossedPrism",22},"VertexList"],GraphData[{"CrossedPrism",22},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

FindSubgraphUnitDistanceEmbedding

{{"CrossedPrism",22},l=FindSubgraphUnitDistanceEmbedding[GraphData[{"CrossedPrism",22}],TimeConstraint->Infinity,"Results"->All]//Timing}

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"CrossedPrism",22},"Graph","Matchstick"]//StyleGraphs

3D

Graph3D[GraphData[{"CrossedPrism",22},"Edges"]]

{"CrossedPrism", 24}

Names

GraphData[{"CrossedPrism",24},"StandardName"]

GraphData[{"CrossedPrism",24},"StandardNames"]

Primary

GraphData[{"CrossedPrism",24}]//StyleGraphs[#,ImageSize->Small]&

All

GraphData[{"CrossedPrism",24},"Graph","All"]//StyleGraphs

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"CrossedPrism",24},"EdgeList"]]

Default embedding

g=Graph@GraphData[{"CrossedPrism",24},"Edges"]

g=CrossedPrismGraph[24]

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

RecognizeGraph[g]

Degenerate

GraphData[{"CrossedPrism",24},"Graph","Degenerate"]//StyleGraphs

DegenerateGraphEmbeddingTypes/@GraphData[{"CrossedPrism",24},"Graph","Degenerate"]

Perspective

GraphData[{"CrossedPrism",24},"Graph","Perspective"]//StyleGraphs

Perspective construction

PolyhedronGraph[GraphData[{"CrossedPrism",24},"Polyhedron"]]

HoneycombToroidal construction

GraphData[{"CrossedPrism",24},"NotationRules","HoneycombToroidal"]

HoneycombToroidalGraph[1,48,23]

RecognizeGraph[%]

GeneralizedHoneycombGraph construction

With[{n=48},Cases[Table[{k,g=GeneralizedHoneycombGraph[n,k],RecognizeGraph@g},{k,n-1}],{__,{"CrossedPrism",24}}]]//Timing

g=GeneralizedHoneycombGraph[48,23]

RecognizeGraph@g

CrossedPrismGraph[24,GraphLayout->"HoneycombToroidalEmbedding"]

RecognizeGraph@%

Bilateral

GraphData[{"CrossedPrism",24},"Graph","Bilateral"]//StyleGraphs

Circular

GraphData[{"CrossedPrism",24},"Graph","Circular"]//StyleGraphs

Bilateral

GraphData[{"CrossedPrism",24},"Planar"]

GraphData[{"CrossedPrism",24},"Graph","Planar"]//StyleGraphs

Planar

GraphData[{"CrossedPrism",24},"Planar"]

GraphData[{"CrossedPrism",24},"Graph","Planar"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",24},{"RCN","CN"}]

GraphData[{"CrossedPrism",24},"Graph","MinimalCrossing"]//StyleGraphs

MinimalCrossing construction

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

Circulant

GraphData[{"CrossedPrism",24},"Circulant"]

GraphData[{"CrossedPrism",24},"Graph","Circulant"]//StyleGraphs

Complement graph

GraphData[{"CrossedPrism",24},"ComplementGraph","Name"]

Line graph

GraphData[{"CrossedPrism",24},"Line"]

LineGraphQ[GraphData[{"CrossedPrism",24}]]//Timing

RootGraph

Select[GraphData[All],GraphData[#,"LineGraph","Name"]=== {"CrossedPrism",24}&]

RootGraph[GraphData[{"CrossedPrism",24}]]

Halin

GraphData[{"CrossedPrism",24},"Halin"]

GraphData[{"CrossedPrism",24},"Graph","Halin"]//StyleGraphs

Rigid

GraphData[{"CrossedPrism",24},"Rigid"]

GraphData[{"CrossedPrism",24},"Graph","Rigid"]//StyleGraphs

Flexible

GraphData[{"CrossedPrism",24},"Flexible"]

GraphData[{"CrossedPrism",24},"Graph","Flexible"]//StyleGraphs

LCF

GraphData[{"CrossedPrism",24},"LCF"]

GraphData[{"CrossedPrism",24},"HamiltonianCycleCount"]

GraphData[{"CrossedPrism",24},"LCFSignature"]

GraphData[{"CrossedPrism",24},"LCFNotations"]

GraphData[{"CrossedPrism",24},"Graph","LCF"]//StyleGraphs

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

LCF compute all

Divisors[GraphData[{"CrossedPrism",24},"V"]]

Length[FindHamiltonianCycle[GraphData[{"CrossedPrism",24}],All][[All,All,1]]]//Timing

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

lcf

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@%

UnitDistance

GraphData[{"CrossedPrism",24},"UnitDistance"]

UnitDistanceGraphQ[GraphData[{"CrossedPrism",24}],Debug->True]//Timing

GraphData[{"CrossedPrism",24},"Graph","UnitDistance"]//StyleGraphs

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"CrossedPrism",24},"VertexList"],GraphData[{"CrossedPrism",24},"EdgeList"]],MaxIterations->500]

UnitDistanceGraphEmbeddingQ[%]

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

Select[%,UnitDistanceGraphEmbeddingQ]

UnitDistance by FindUnitDistanceEmbedding

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

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

FindSubgraphUnitDistanceEmbedding

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

gs=UniqueEmbeddings[l]

Matchstick

GraphData[{"CrossedPrism",24},"Graph","Matchstick"]//StyleGraphs

MinimalCrossing

GraphData[{"CrossedPrism",24},{"RCN","CN"}]

GraphData[{"CrossedPrism",24},"Graph","MinimalCrossing"]//StyleGraphs

3D

Graph3D[GraphData[{"CrossedPrism",24},"Edges"]]

Properties

Acyclic

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

AdjacencyMatrixCount

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

Table[(((4n)!)/(Piecewise[{{48,n==2}},(2^(1+n)) n])),{n,2,10}]

FullSimplify[(((4n)!)/(Piecewise[{{48,n==2}},(2^(1+n)) n]))]

Table[Piecewise[{{840,n==2}},(2^(1-n))Gamma[4n]],{n,2,10}]

Arboricity

seq=Table[GraphData[{"CrossedPrism",2n},"Arboricity"],{n,2,10}]

ArcTransitivity

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

ArcTransitive

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

ArcTransitivity

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

AutomorphismCount

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

FindSequenceFunction[Rest@seq,n-2]

Table[Piecewise[{{48,n==2}},(2^(1+n)) n],{n,2,10}]

BalabanIndex

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

FindSequenceFunction[seq,n-1]//Factor

Bandwidth

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

BridgeCount

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

BurningNumber

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

CharacteristicPolynomial

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

FullSimplify[poly2-poly]

Chordal

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

ChordCount

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

FindSequenceFunction[seq,n-1]

Chordless

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

ChordlessCycleCount

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-1]//Factor

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

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

Chords

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

ChromaticallyUnique

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

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

ChromaticInvariant

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

FindLinearRecurrence[DeleteMissing[seq]]

FindSequenceFunction[DeleteMissing[seq],n-1]//FullSimplify

ChromaticNumber

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

ChromaticPolynomial

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

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly]

coef=Factor/@FindLinearRecurrence[DeleteMissing@poly/(x(x-1))]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

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

FullSimplify[poly2-poly]

Circumference

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

FindSequenceFunction[seq,n-1]

Classes

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

CliqueCount

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

FindSequenceFunction[seq,n-1]//Factor

CliqueCoveringNumber

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

FindSequenceFunction[seq,n-1]

CliqueNumber

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

CliquePolynomial

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

FullSimplify[poly2-poly]

CochromaticGraphNames

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

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

ComplementOddChordlessCycleCount

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

ConnectedComponentCount

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

ConnectedDominatingSetCount

A287430

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

FindLinearRecurrence[DeleteMissing[seq]]

FindSequenceFunction[DeleteMissing[seq],n-1]//FullSimplify

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

ConnectedDominationNumber

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

ConnectedDominationPolynomial

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

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

FullSimplify[poly2-poly]

ConnectedInducedSubgraphCount

A290757

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

FindLinearRecurrence[DeleteMissing[seq]]

FindSequenceFunction[DeleteMissing[seq],n]

gf=FindGeneratingFunction[DeleteMissing[seq],x]

ConnectedInducedSubgraphPolynomial

(poly=DeleteCases[Factor@Table[GraphData[{"CrossedPrism",2n},"ConnectedInducedSubgraphPolynomial"][x],{n,k0=2,6}],_Missing[x]])//Column

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

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

FullSimplify[poly2-poly]

CrossingNumber

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

CycleCount

A234617

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

seq={6,28,107,380,1345,4878,18219,69736,271589,1069538,4240351,16877532,67325913,268902358,1074741203,4297097168,17184391117,68729044938,274898091975,1099554095044,4398135640001,17592372690878,70369134247867,281475790405560,1125901601341365};

FindLinearRecurrence[seq]

FindSequenceFunction[DeleteMissing[seq],n]

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

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

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

CyclePolynomial

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

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

FullSimplify[poly2-poly]

Cyclic

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

CyclomaticNumber

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

FindSequenceFunction[seq,n-1]//Factor

DetourIndex

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

FindSequenceFunction[seq,n-1]//Factor

DetourMatrix

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

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

DetourPolynomial

(poly=Factor[Table[GraphData[{"CrossedPrism",2n},"DetourPolynomial"],{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,k0,kmax}]

FullSimplify[poly2-poly]

Diameter

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

DistanceMatrix

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

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

DistancePolynomial

(poly=Factor[Table[GraphData[{"CrossedPrism",2n},"DistancePolynomial"],{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,k0,kmax}]

FullSimplify[poly2-poly]

DistinguishingNumber

Probably 2 for n > 4

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

DomaticNumber

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

DominatingSetCount

A287062

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

seq={11,183,2417,32499,436281,5857683,78646537,1055926979,14177123321,190345385523,2555621823337,34312378451619,460686046833881,6185278996234003,83045007601555017,1114981764240774019,14970006873311301561,200990826015513435123};

FindLinearRecurrence[DeleteMissing[seq]]

FindSequenceFunction[DeleteMissing[seq],n]

LinearRecurrence[{11,31,21,2},{11,183,2417,32499},20]

Table[(-1)^n+RootSum[-2-19 #-12 ((#)^2)+((#)^3)&,#^n&],{n,20}]

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

DominationNumber

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

Table[2Ceiling[n/4],{n,2,10}]

DominationPolynomial

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

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

FullSimplify[poly2-poly]

EdgeChromaticNumber

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

EdgeConnectivity

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

EdgeCount

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

FindSequenceFunction[seq,n-1]

EdgeCoverCount

A297028

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

FindLinearRecurrence[DeleteMissing@seq]

FindSequenceFunction[DeleteMissing@seq,n-1]

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

EdgeCoverNumber

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

FindSequenceFunction[seq,n-1]

EdgeCoverPolynomial

(poly=Factor[Table[GraphData[{"CrossedPrism",2n},"EdgeCoverPolynomial"],{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]

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

FullSimplify[poly2-poly]

EdgeCutCount

seq=Table[GraphData[{"CrossedPrism",2n},"EdgeCutCount"],{n,2,10}]

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

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

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

EdgeCutPolynomial

(poly=Table[GraphData[{"CrossedPrism",2n},"EdgeCutPolynomial"],{n,2,10}]/.f_Function:>f[x])//Column

EulerianCycleCount

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

FaceCount

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

FlowPolynomial

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

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

FullSimplify[poly2-poly]

FractionalChromaticNumber

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

FractionalEdgeChromaticNumber

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

Girth

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

Gonality

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

HamiltonConnected

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

HamiltonDecompositionCount

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

FindSequenceFunction[seq,n-1]

Hamiltonian

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

HamiltonianCycleCount

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

FindSequenceFunction[seq,n-1]

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

HamiltonianNumber

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

FindSequenceFunction[seq,n-1]

HamiltonianPathCount

2*A137885(n)

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

FindLinearRecurrence[seq]

LinearRecurrence[{6,-12,8},{72,288,960},{0,20}]

FindSequenceFunction[seq,n-1]

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

HamiltonianWalkCount

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

HararyIndex

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

FindSequenceFunction[seq,n-1]//FunctionExpand//FullSimplify

HexagonCount

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

FindSequenceFunction[seq,n-1]

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

IdiosyncraticPolynomial

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

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

FullSimplify[poly2-poly]

IndependenceNumber

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

FindSequenceFunction[seq,n-1]

IndependencePolynomial

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

FullSimplify[poly2-poly]

IndependenceRatio

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

IndependentEdgeSetCount

A293126

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

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

Table[RootSum[-4+18 #-12 ((#)^2)+((#)^3)&,#^n&],{n,0,20}]

RootSum[-4+18 #-12 ((#)^2)+((#)^3)&,#^Range[0,20]&]

FindLinearRecurrence[DeleteMissing@seq]

seq=LinearRecurrence[{12,-18,4},{12,108,1092},{0,20}]

gf=x FindGeneratingFunction[seq,x]

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

IndependentVertexSetCount

A287327

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

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

Table[((((1/2) (7-(Sqrt[21]))))^n)+((((1/2) (7+(Sqrt[21]))))^n),{n,0,10}]//Expand

FindLinearRecurrence[DeleteMissing@seq]

LinearRecurrence[{7,-7},{7,35},{0,20}]

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

IntersectionNumber

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

IrredundantSetCount

A290708

seq=Table[GraphData[{"CrossedPrism",2n},"IrredundantSetCount"],{n,2,10}]

seq={9,77,609,5221,44914,383279,3267224,27844845,237311925,2022585862,17238412156,146922412111,1252214688188,10672581690652,90962034893584,775266190295021,6607566186841867,56316051804768503,479979708366734131,4090849998653543166};

coef=FindLinearRecurrence[DeleteMissing@seq]

Take[seq,Length@coef]

LinearRecurrence[{9,-2,-22,23,126,-2,-184,-64},{9,77,609,5221,44914,383279,3267224,27844845},20]

FindSequenceFunction[DeleteMissing@seq,n]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

res=Refine[SeriesCoefficient[gf,{x,0,n}],n>0]

terms=List@@res;

N[terms/.n->0]//Chop

terms[[All,1]]

Table[RootSum[64+184 #1+2 ((#1)^2)-126 ((#1)^3)-23 ((#1)^4)+22 ((#1)^5)+2 ((#1)^6)-9 ((#1)^7)+((#1)^8)&,#^n&],{n,20}]

KirchhoffIndex

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

FindSequenceFunction[seq,n-1]//Factor

KirchhoffSumIndex

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

seq=Table[KirchhoffSumIndex[CrossedPrism[2n]],{n,2,20}]

FindSequenceFunction[seq,n-1]//Factor

LaplacianMatrix

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

LaplacianPolynomial

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

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

FullSimplify[poly2-poly]

LeafCount

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

LongestCycleCount

===|HC|

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

LovaszNumber

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

MatchingGeneratingPolynomial

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

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

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

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

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

FullSimplify[poly2-poly]

MatchingNumber

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

FindSequenceFunction[seq,n-1]

MatchingPolynomial

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

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

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

FullSimplify[poly2-poly]

MaximalCliqueCount

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

FindSequenceFunction[seq,n-1]

MaximalIndependentEdgeSetCount

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-1]

FindSequenceFunction[Rest@seq,n-2]

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

MaximalIndependentVertexSetCount

A276225

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

FindSequenceFunction[seq,n-1]

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

MaximumCliqueCount

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

FindSequenceFunction[seq,n-1]

MaximumIndependentEdgeSetCount

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

FindSequenceFunction[seq,n-1]

MaximumIndependentVertexSetCount

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

MaximumLeafNumber

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

MaximumVertexDegree

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

MeanDistance

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

FindSequenceFunction[seq,n-1]//Factor

MinimalDominatingSetCount

A291772

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

FindLinearRecurrence[DeleteMissing@seq]

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

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

MinimalDominatingSetSignature

seq=Table[GraphData[{"CrossedPrism",2n},"MinimalDominatingSetSignature"],{n,2,10}]//Column

MinimalEdgeCoverCount

A351586

seq=Table[GraphData[{"CrossedPrism",2n},"MinimalEdgeCoverCount"],{n,2,10}]

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

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

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

LinearRecurrence[{5,12,40,56,-8,-32},{5,49,425,3137,22985,172081},20]

Table[RootSum[32+8 #-56 #^2-40 #^3-12 #^4-5 #^5+#^6&,#^n&],{n,20}]

CoefficientList[Series[(5+24 x+120 x^2+224 x^3-40 x^4-192 x^5)/(1-5 x-12 x^2-40 x^3-56 x^4+8 x^5+32 x^6),{x,0,20}],x]

MinimalEdgeCoverPolynomial

(poly=Table[GraphData[{"CrossedPrism",2n},"MinimalEdgeCoverPolynomial"],{n,2,10}]/.f_Function:>f[x])//Column

MinimalEdgeCutCount

seq=Table[GraphData[{"CrossedPrism",2n},"MinimalEdgeCutCount"],{n,2,10}]

FindLinearRecurrence[DeleteMissing@seq]

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

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

MinimalEdgeCutPolynomial

(poly=Table[GraphData[{"CrossedPrism",2n},"MinimalEdgeCutPolynomial"],{n,2,10}]/.f_Function:>f[x])//Column

MinimumCliqueCoveringCount

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

MinimumConnectedDominatingSetCount

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

FindSequenceFunction[DeleteMissing[seq],n]

MinimumDistinguishingLabelingCount

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

MinimumDominatingSetCount

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

DeleteMissing@seq[[1;;All;;2]]

FindSequenceFunction[%,n]

DeleteMissing@seq[[2;;All;;2]]

FindSequenceFunction[%,n]

MinimumEdgeCoverCount

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

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

MinimumEdgeCutCount

A297028

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

FindLinearRecurrence[DeleteMissing@seq]

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

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

MinimumVertexDegree

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

MolecularTopologicalIndex

A192793

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

FindLinearRecurrence[seq]

LinearRecurrence[{4,-6,4,-1},{360,900,1872,3420},{0,20}]

LinearRecurrence[{4,-6,4,-1},{108,360,900,1872},{2,20}]

FindSequenceFunction[seq,n-1]//FullSimplify

Table[12 n (7+2 (n^2)),{n,2,10}]

NormalizedLaplacianMatrix

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

OddChordlessCycleCount

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

PathCount

A288714

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

seq={26,444,3654,22888,124850,628860,3014438,13987152,63462906,283337380,1249770830,5460869112,23680912034,102049764684,437447065590,1866647382688,7933717075274,33602668068852,141880252869278,597395676419400,2509073159290866,10514236156062364};

FindLinearRecurrence[DeleteMissing@seq]

LinearRecurrence[{16,-105,366,-732,840,-512,128},{26,444,3654,22888,124850,628860,3014438},20]

FindSequenceFunction[DeleteMissing@seq,n]//FullSimplify

Table[n (163 (4^n)-9 (2^(n+3)) n-87 (2^(n+1))-4)/6,{n,20}]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[-((2 (13+14 x-360 (x^2)+764 (x^3)-580 (x^4)+152 (x^5)))/((((-1+2 x))^3) (((1-5 x+4 (x^2)))^2))),{x,0,20}],x]

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

PathPolynomial

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

coef=Factor/@FindLinearRecurrence[poly]

ToPolynomialRecurrence[p,x,n,coef]

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

TeXForm[%]

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

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

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

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

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

FullSimplify[poly2-poly]

PentagonCount

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

Perfect

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

ProjectivePlaneCrossingNumber

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

Radius

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

RankPolynomial

(poly=Factor[Table[GraphData[{"CrossedPrism",2n},"RankPolynomial"],{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]

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

FullSimplify[poly2-poly]

RectilinearCrossingNumber

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

ReliabilityPolynomial

(poly=Factor[Table[GraphData[{"CrossedPrism",2n},"ReliabilityPolynomial"],{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]

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

FullSimplify[poly2-poly]

SigmaPolynomial

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

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

FullSimplify[poly2-poly]

SpanningTreeCount

A193132

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

FindSequenceFunction[seq,n-1]//FullSimplify

SquareCount

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

FindSequenceFunction[Rest@seq,n-2]

StabilityIndex

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

FindSequenceFunction[seq,n-1]//FullSimplify

TopologicalIndex

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

FindSequenceFunction[seq,n-1]

FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

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

Traceable

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

TriangleCount

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

TuttePolynomial

(poly=Factor[Table[GraphData[{"CrossedPrism",2n},"TuttePolynomial"],{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]

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

FullSimplify[poly2-poly]

Untraceable

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

VertexConnectivity

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

VertexCount

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

FindSequenceFunction[seq,n-1]

VertexCoverNumber

vertex cover number == vertex count - independence number

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

VertexCoverPolynomial

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

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

FullSimplify[poly2-poly]

VertexDegrees

seq=Table[GraphData[{"CrossedPrism",2n},"VertexDegrees"],{n,2,10}]

VertexTransitive

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

WienerIndex

A292022

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

FindSequenceFunction[seq,n-1]//Factor

seq=Table[4n((n^2)+2),{n,50}]

coef=FindLinearRecurrence[seq]

Take[seq,Length@coef]

LinearRecurrence[{4,-6,4,-1},{12,48,132,288},20]

gf=x FindGeneratingFunction[seq,x]

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

WienerSumIndex

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

seq=Table[WienerSumIndex[CrossedPrism[2n]],{n,2,20}]

FindSequenceFunction[seq,n-1]

GraphData

GraphClassString[{"CrossedPrism",#}&/@Range[4,10,2]]

GraphDataString

Table[Print[GraphDataString[CrossedPrism[n],
"Name"->ToString[n]<>"-crossed prism graph",
"StandardName"->{"CrossedPrism",2n},
TimeConstraint->10
]],{n,4,20,2}]