Tetrahedral Johnson Graph

Author

Eric W. Weisstein
October 23, 2024

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

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

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

Graphic

GraphicsRow[Table[Annotate[StyleGraphs@GraphData[gn={"Tetrahedral",n}],PlotLabel->Style[GraphData[gn,"Notation"]/.{","->", ","J"->Style["J",Italic]},Directive[Black,18,FontFamily->"Times"]]],{n,6,8}],Dividers->All]

Properties

Table[TetrahedralGraph[n],{n,6,10}]

ToEntity/@%

Acyclic

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

AdjacencyMatrixCount

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

FullSimplify[((Binomial[n,3]!)/(Piecewise[{{2,n==6}},1]n!))]

Table[((Binomial[n,3]!)/(Piecewise[{{2,n==6}},1]n!)),{n,6,10}]

Arboricity

Table[GraphData[{"Tetrahedral",n},"Arboricity"],{n,6,10}]

ArcTransitive

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

ArcTransitivity

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

AutomorphismCount

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

(seq=Table[GroupOrder[GraphAutomorphismGroup[TetrahedralGraph[n]]],{n,6,18}])//Timing

FindSequenceFunction[seq,n-5]

FindSequenceFunction[Rest@seq,n-6]

bug(336613)

Table[Piecewise[{{2,n==6}},1]n!,{n,6,10}]

FindLinearRecurrence[seq]

BalabanIndex

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

(seq=Monitor[Table[BalabanIndex[TetrahedralGraph[n]],{n,6,18}],n])//Timing

FindSequenceFunction[seq,n-5]//Factor

Table[((3 (-3+n) (-2+n) (-1+n) (n^2))/(2 (24-22 n+39 (n^2)-20 (n^3)+3 (n^4)))),{n,18}]

Binomial[n,4]

Table[((36n Binomial[n,4])/((24-22 n+39 (n^2)-20 (n^3)+3 (n^4)))),{n,18}]

gf=(x^6)FindGeneratingFunction[seq,n-5]

Bandwidth

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

BridgeCount

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

BurningNumber

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

CharacteristicPolynomial

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

FindSequenceFunction[{14,20,27,35},n-6]//Factor

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

FindSequenceFunction[{5,14,28,48,75},n-6]//Factor

poly/poly2

Chordal

seq=Table[GraphData[{"Tetrahedral",n},"Chordal"],{n,6,10}]

ChordCount

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

Chordless

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

ChordlessCycleCount

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

Chords

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

ChromaticallyUnique

seq=Table[GraphData[{"Book",n},"ChromaticallyUnique"],{n,20}]

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

ChromaticInvariant

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

FindSequenceFunction[Drop[seq,2],n]

ChromaticNumber

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

FindSequenceFunction[Drop[seq,2],n]

Classes

Intersection@@GraphData["Tetrahedral","Classes"]

ChromaticPolynomial

(poly=Factor[Table[GraphData[{"Tetrahedral",n},"ChromaticPolynomial"],{n,k0=6,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]

Circumference

seq=Table[GraphData[{"Tetrahedral",n},"Circumference"],{n,6,10}]

FindSequenceFunction[seq,n-5]//Factor

Binomial[n,3]

Classes

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

CliqueCount

A289837

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

(seq=Monitor[Table[Length@FindAllCliques[TetrahedralGraph[n]],{n,6,20}],n])//Timing

Length@FindAllCliques[TetrahedralGraph[21]]//Timing

seq={261,757,2003,5035,12286,29426,69554,162670,376923,865971,1973941,4466853,10040524,22430584,49829116,110127536};

seq={1,1,2,16,76,261,757,2003,5035,12286,29426,69554,162670,376923,865971,1973941,4466853,10040524,22430584,49829116,110127536,242254321,530619937,1157676711,2516640751,5452664426,11777687182,25367246038,54492508610,11676955183};

FindLinearRecurrence[seq]

FindLinearRecurrence[Rest@seq]

FindSequenceFunction[seq,n]

gf=x FindGeneratingFunction[seq,x]

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

seq=Table[(2^(n-2)-n+1)Binomial[n,2]+Binomial[n,3]+5Binomial[n,4]+1,{n,100}]

coef=FindLinearRecurrence[seq]

Take[seq,Length[coef]]

LinearRecurrence[{11,-52,138,-225,231,-146,52,-8},{1,1,2,16,76,261,757,2003},20]

gf=x FindGeneratingFunction[seq,x]

CoefficientList[Series[((1-10 x+43 (x^2)-92 (x^3)+91 (x^4)-25 (x^5)-5 (x^6)-8 (x^7))/((((-1+x))^5) (((-1+2 x))^3))),{x,0,20}],x]

CliqueCoveringNumber

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

FindSequenceFunction[seq,n-5]

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

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

CliqueNumber

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

CliquePolynomial

(poly=Factor[Table[GraphData[{"Tetrahedral",n},"CliquePolynomial"],{n,k0=6,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[{"Tetrahedral",n},"CochromaticGraphNames"],{n,6,10}]

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

ComplementOddChordlessCycleCount

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

ConnectedComponentCount

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

ConnectedDominatingSetCount

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

ConnectedDominationNumber

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

ConnectedDominationPolynomial

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

ConnectedInducedSubgraphCount

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

FindSequenceFunction[DeleteMissing[seq],n]

ConnectedInducedSubgraphPolynomial

(poly=Factor[Table[GraphData[{"Tetrahedral",n},"ConnectedInducedSubgraphPolynomial"],{n,k0=6,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,6}]

FullSimplify[poly2-poly]

CrossingNumber

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

CycleCount

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

FindSequenceFunction[DeleteMissing[seq],n]

CyclePolynomial

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

CyclomaticNumber

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

FindSequenceFunction[seq,n-5]

Factor[6Binomial[n,4]-Binomial[n,3]+1]

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

DetourIndex

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

FindSequenceFunction[seq,n-5]

DetourMatrix

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

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

DetourPolynomial

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

FindSequenceFunction[{361,1156,3025,6889,14161},n]

FindSequenceFunction[{19,34,55,83,119},n-5]//Factor

Table[(x-XXX)(((x+((n^2)+2)(n-3)/6))^(((n^2)+2)(n-3)/6)),{n,6,10}]//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[{"Tetrahedral",n},"Diameter"],{n,6,10}]

DistanceMatrix

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

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

DistancePolynomial

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

FindSequenceFunction[{30,60,105,168,252},n-5]//Factor

3Binomial[n-1,3]

FindSequenceFunction[{14,28,48,75,110},n-5]//Factor

FindSequenceFunction[{6,10,15,21,28},n-5]//Factor

Binomial[n-2,2]

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

poly/poly

DistinguishingNumber

seq=Table[GraphData[{"Tetrahedral",n},"DistinguishingNumber"],{n,6,10}]

DominatingSetCount

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

DominationNumber

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

(seq=Monitor[Table[DominationNumber[TetrahedralGraph[n]],{n,6,9}],n])//Timing

DominationPolynomial

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

EdgeChromaticNumber

seq=Table[GraphData[{"Tetrahedral",n},"EdgeChromaticNumber"],{n,6,10}]

FindSequenceFunction[seq,n-5]

gf=x FindGeneratingFunction[seq,x]

EdgeConnectivity

seq=Table[GraphData[{"Tetrahedral",n},"EdgeConnectivity"],{n,6,10}]

FindSequenceFunction[seq,n-5]//Factor

EdgeCount

seq=Table[GraphData[{"Tetrahedral",n},"EdgeCount"],{n,6,10}]

seq=Table[EdgeCount[TetrahedralGraph[n]],{n,6,20}]

FindSequenceFunction[seq,n-5]//Factor

6Binomial[n,4]

EdgeCoverCount

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

EdgeCoverNumber

Binomial[n,3]-A011894

Table[Binomial[n,3]-Floor[Binomial[n,3]/2],{n,6,16}]

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

(seq=Monitor[Table[EdgeCoverNumber[TetrahedralGraph[n]],{n,6,16}],n])//Timing

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-5]

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

EdgeCoverPolynomial

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

EulerianCycleCount

seq=Table[GraphData[{"Tetrahedral",n},"EulerianCycleCount"],{n,6,10}]

FaceCount

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

FlowPolynomial

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

FractionalChromaticNumber

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

Table[FractionalChromaticNumber[TetrahedralGraph[n]],{n,6,7}]

FractionalEdgeChromaticNumber

Probably 3(n-3) for n =! 8

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

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

Girth

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

Gonality

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

HamiltonConnected

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

HamiltonDecompositionCount

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

Hamiltonian

Table[GraphData[{"Tetrahedral",n},"Hamiltonian"],{n,6,10}]

HamiltonianCycleCount

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

HamiltonianNumber

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

FindSequenceFunction[seq,n-5]//Factor

Binomial[n,3]

HamiltonianPathCount

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

HamiltonianWalkCount

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

HararyIndex

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

(seq=Monitor[Table[HararyIndex[TetrahedralGraph[n]],{n,6,15}],n])//Timing

FindSequenceFunction[seq,n-5]//Factor

FindGeneratingFunction[seq,x]

HexagonCount

A289794

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

seq=Table[CycleCount[TetrahedralGraph[n],6],{n,6,15}]

FindSequenceFunction[seq,n-5]//Factor

Binomial[n,5]

seq=Table[5Binomial[n,5](454-409 n+66 (n^2)+(n^3)),{n,40}]

coef=FindLinearRecurrence[seq]

Take[seq,Length[coef]]

LinearRecurrence[{9,-36,84,-126,126,-84,36,-9,1},{0,0,0,0,920,17760,122640,537040,1794240},20]

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

ToString[%,InputForm]

CoefficientList[Series[((40 (x^4) (-23-237 x+102 (x^2)+116 (x^3)))/(((-1+x))^9)),{x,0,20}],x]

IdiosyncraticPolynomial

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

FindSequenceFunction[{9,12,15,18,21},n-5]//Factor

FindSequenceFunction[{10,22,40,65,98},n-5]//Factor

FindSequenceFunction[{5,14,28,48,75},n-5]//Factor

FindSequenceFunction[{14,20,27,35},n-6]//Factor

(poly2=Table[(x-3 (-3+n)-(1/6) (-4+n) (-3+n) (4+n)y)(((3+x-2y))^((-5+n) (-1+n) n/6))(((-n+7+x+(n-6)y))^(n(n-3)/2))(((-(2n-9)+x+(2n-8)y))^(n-1)),{n,6,10}])//Column

poly/poly2

IndependenceNumber

Probably A001839

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

Do[Print[{n,MemoryConstrained[{Length[i=First@FindIndependentVertexSet[TetrahedralGraph[n]]],i},100*^9]}//Timing],{n,6,12}]

seq=Table[Floor[n Floor[(n-1)/2]/3]-Boole[Mod[n,6]==5],{n,200}]

coef=FindLinearRecurrence[seq]

Take[seq,Length[coef]]

RSolve[Prepend[Table[a[k]==seq[[k]],{k,Length[coef]}],a[n]==Sum[a[n-k]coef[[k]],{k,Length[coef]}]],a[n],n]//FullSimplify[#,n∈Integers]&

Table[(6 (n^2)-9n-10-3 (((-1))^n) (n-2)-6 Cos[((n π)/3)]+10 Cos[((2 n π)/3)]+10 (Sqrt[3]) Sin[((n π)/3)]+6 (Sqrt[3]) Sin[((2 n π)/3)])/36,{n,30}]

LinearRecurrence[{1,1,-1,0,0,1,-1,-1,1},{0,0,1,1,2,4,7,8,12},20]

FindSequenceFunction[Take[seq,100],n]

FindSequenceFunction[seq,n]

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

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

IndependencePolynomial

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

CoefficientList[Take[poly,4],x]

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]

IndependenceRatio

seq=Table[GraphData[{"Tetrahedral",n},"IndependenceRatio"],{n,6,10}]

FindSequenceFunction[seq,n-5]

IndependentEdgeSetCount

A293244

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

IndependentVertexSetCount

A287232

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

FindLinearRecurrence[DeleteMissing[seq]]

FindSequenceFunction[DeleteMissing[seq],n-5]

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

IntersectionNumber

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

KirchhoffIndex

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

(seq=Monitor[Table[KirchhoffIndex[TetrahedralGraph[n]],{n,6,13}],n])//Timing

FindSequenceFunction[seq,n-5]//Factor

KirchhoffSumIndex

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

(seq=Monitor[Table[KirchhoffSumIndex[TetrahedralGraph[n]],{n,6,13}],n])//Timing

FindSequenceFunction[seq,n-5]//Factor

LaplacianMatrix

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

LaplacianPolynomial

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

FindSequenceFunction[{5,14,28,48,75},n-5]//Factor

FindSequenceFunction[{9,14,20,27,35},n-5]//Factor

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

poly/poly2

coef=Factor/@FindLinearRecurrence[poly]

LeafCount

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

LongestCycleCount

==|HC|

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

LovaszNumber

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

MatchingGeneratingPolynomial

(poly=Factor[Table[GraphData[{"Tetrahedral",n},"MatchingGeneratingPolynomial"],{n,k0=6,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]

MatchingNumber

A011894

seq=Table[GraphData[{"Tetrahedral",n},"MatchingNumber"],{n,6,10}]

Table[Floor[Binomial[n,3]/2],{n,6,10}]

(seq=Table[MatchingNumber[TetrahedralGraph[n]],{n,6,17}])//Timing

seq=Table[Floor[Binomial[n,3]/2],{n,6,40}]

ceof=FindLinearRecurrence[seq]

LinearRecurrence[{3,-3,1,1,-3,3,-1},{0,0,0,2,5,10,17},20]

FindSequenceFunction[seq,n-5]//FullSimplify[#,n∈Integers]&

Table[(3 ((((-1))^n)-1)+2 (n-2) (n-1) n+6 Sin[((n π)/2)])/24,{n,20}]

gf=(x^6) FindGeneratingFunction[seq,x]//Factor

Series[gf,{x,0,20}]

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

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

MatchingPolynomial

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

MaximalCliqueCount

A055795

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

(seq=Table[Length@FindClique[TetrahedralGraph[n],Infinity,All],{n,6,12}])//Timing

FindSequenceFunction[seq,n-5]

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

Table[Binomial[n,4]+Binomial[n,2],{n,6,12}]

MaximalIndependentEdgeSetCount

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

MaximalIndependentVertexSetCount

A290611

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

MaximumCliqueCount

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

FindSequenceFunction[seq,n-5]

gf=(x^6)FindGeneratingFunction[seq,x]//Factor

Series[(((x^6) (-30+69 x-55 (x^2)+15 (x^3)))/(((-1+x))^3)),{x,0,20}]

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

MaximumIndependentEdgeSetCount

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

MaximumIndependentVertexSetCount

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

MaximumLeafNumber

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

MaximumVertexDegree

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

MeanDistance

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

FindSequenceFunction[seq,n-5]

MinimumCliqueCoveringCount

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

MinimumConnectedDominatingSetCount

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

FindSequenceFunction[seq,n-5]

MinimumDistinguishingLabelingCount

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

MinimumDominatingSetCount

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

MinimumEdgeCoverCount

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

MinimumVertexDegree

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

FindSequenceFunction[seq,n-5]

MolecularTopologicalIndex

A192847

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

seq=Table[n(n-1)(n-2)(n-3)^2(n^2-3n+8)/4,{n,6,20}]

FindSequenceFunction[seq,n-5]//Factor

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

Binomial[n,4]

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

coef=FindLinearRecurrence[seq]

"a(n)="<>StringReplace[StringJoin@@Table[If[coef[[k]]==0,"",Switch[
coef[[k]],
-1,"-",
1,"+",
_,ToString[coef[[k]]]<>"*"]<>"a(n-"<>ToString[k]<>")+"],{k,Length[coef]}],"+-"->"-"]

LinearRecurrence[{8,-28,56,-70,56,-28,8,-1},{0,0,0,72,1080,7020,30240,100800},20]

FindSequenceFunction[seq,n]//Factor

gf=(x^4)FindGeneratingFunction[Drop[seq,3],x]//Factor

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

CoefficientList[Series[((36 (x^3) (2+14 x+11 (x^2)+8 (x^3)))/(((-1+x))^8)),{x,0,20}],x]

Nonhamiltonian

Table[GraphData[{"Tetrahedral",n},"Nonhamiltonian"],{n,6,10}]

NormalizedLaplacianMatrix

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

OddChordlessCycleCount

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

PathCount

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-5]

gf=x FindGeneratingFunction[seq,x]

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

PathPolynomial

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

PentagonCount

A289793

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

seq=Table[CycleCount[TetrahedralGraph[n],5],{n,6,15}]

FindSequenceFunction[seq,n-5]//Factor

Table[6Binomial[n,5](-78+21 n+(n^2)),{n,20}]

seq=Table[(1/20) (-4+n) (-3+n) (-2+n) (-1+n) n (-78+21 n+(n^2)),{n,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{8,-28,56,-70,56,-28,8,-1},{0,0,0,0,312,3024,14868,51744},20]

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

ToString[%,InputForm]

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

CoefficientList[Series[-((12 (x^4) (-26-44 x+49 (x^2)))/(((-1+x))^8)),{x,0,20}],x]

Perfect

Table[GraphData[{"Tetrahedral",n},"Perfect"],{n,6,10}]

ProjectivePlaneCrossingNumber

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

Radius

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

RankPolynomial

(poly=Factor[Table[GraphData[{"Tetrahedral",n},"RankPolynomial"],{n,k0=6,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]

RectilinearCrossingNumber

seq=Table[GraphData[{"Tetrahedral",n},"RectilinearCrossingNumber"],{n,6,10}]

ReliabilityPolynomial

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

SigmaPolynomial

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

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

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-5]

SquareCount

A289792

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

seq=Table[CycleCount[TetrahedralGraph[n],4],{n,6,20}]

FindLinearRecurrence[seq]

seq=LinearRecurrence[{7,-21,35,-35,21,-7,1},{0,0,0,0,90,540,1995},20]

FindSequenceFunction[seq,n]//Factor

Binomial[n-1,4]

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

Table[(1/48) (-4+n) (-3+n) (-2+n) (-1+n) (210-41 n+7 (n^2)),{n,40}]

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

ToString[gf,InputForm]

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

StabilityIndex

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

(seq=Monitor[Table[StabilityIndex[TetrahedralGraph[n]],{n,6,11}],n])//Timing

seq=Total/@Abs[Table[CoefficientList[(x-3(n-3))(((x-(2n-9)))^(n-1))(((x-(n-7)))^(n(n-3)/2))(((x+3))^((n-5) (n-1) n/6)),x][[1;;All;;2]],{n,6,15}]]

FindSequenceFunction[seq,n-5]

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

TopologicalIndex

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

FindSequenceFunction[seq,n-5]

FindGeneratingFunction[seq,x]

ToroidalCrossingNumber

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

Traceable

Table[GraphData[{"Tetrahedral",n},"Traceable"],{n,6,10}]

TriangleCount

A027789

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

seq=Table[CycleCount[TetrahedralGraph[n],3],{n,6,20}]

FindLinearRecurrence[seq]

FindSequenceFunction[seq,n-5]//Factor

Table[2(n-2)Binomial[n,4],{n,20}]

2(n+1)Binomial[n+3,4]

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

gf=x FindGeneratingFunction[seq,x]

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

TuttePolynomial

(poly=Factor[Table[GraphData[{"Tetrahedral",n},"TuttePolynomial"],{n,k0=6,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]

Untraceable

Table[GraphData[{"Tetrahedral",n},"Untraceable"],{n,6,10}]

VertexConnectivity

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

FindSequenceFunction[seq,n-5]//Factor

VertexCount

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

FindSequenceFunction[seq,n-5]//Factor

Binomial[n,3]

VertexCoverNumber

vertex cover number == vertex count - independence number

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

FindSequenceFunction[seq,n-5]//FullSimplify

gf=x FindGeneratingFunction[seq,x]

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

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

VertexCoverPolynomial

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

VertexTransitive

Table[GraphData[{"Tetrahedral",n},"VertexTransitive"],{n,6,10}]

WienerIndex

A292061

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

(seq=Monitor[Table[WienerIndex[JohnsonGraph[n,3]],{n,6,20}],n])//Timing

FindSequenceFunction[seq,n-5]//Factor

seq=Table[(n-3) (((n-2))^2) (((n-1))^2) n/24,{n,40}]

coef=FindLinearRecurrence[seq]

Length@coef

Take[seq,Length@coef]

LinearRecurrence[{7,-21,35,-35,21,-7,1},{0,0,0,6,60,300,1050},20]

gf=x FindGeneratingFunction[seq,x]

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

WienerSumIndex

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

(seq=Monitor[Table[WienerSumIndex[TetrahedralGraph[n]],{n,6,13}],n])//Timing

FindSequenceFunction[seq,n-5]//Factor

Embeddings

<<MathWorld`Graphs`

GraphData["Tetrahedral"]

{"Tetrahedral", 6}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

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

Default embedding

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

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

RecognizeGraph[g]

Degenerate

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

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

Perspective

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

Perspective construction

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

Bilateral

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

Circular

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

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

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

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

Complement graph

GraphData[{"Tetrahedral",6},"ComplementGraph","Name"]

GraphComplement/@GraphData[%,"Graph","All"]

Line graph

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

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

RootGraph

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

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

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

Divisors[GraphData[{"Tetrahedral",6},"V"]]

LCF compute random

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

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Tetrahedral",6}],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]

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"Tetrahedral",6}],10^6])[[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

BilateralGraphEmbeddingQ/@gs

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Tetrahedral",6}],10^7])[[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

BilateralGraphEmbeddingQ/@gs

LCF compute 5*^7 [90 GB]

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

MaxMemoryUsed[]/10.^9 "GB"

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

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

LCF compute 1*^8 [165 GB]

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

MaxMemoryUsed[]/10.^9 "GB"

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

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

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

Length[gs]

gs

BilateralGraphEmbeddingQ/@gs

LCF compute all

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

Tally[(lcf=LCF[GraphData[{"Tetrahedral",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[{"Tetrahedral",6},"UnitDistance"]

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

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

UnitDistance by refinement

UnitDistanceEmbeddingRefine[Graph[GraphData[{"Tetrahedral",6},"VertexList"],GraphData[{"Tetrahedral",6},"EdgeList"]],MaxIterations->500]

g=LabelGraph@RotateGraph[,{9,7}]

DegenerateGraphEmbeddingTypes@g

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

UnitDistance by FindUnitDistanceEmbedding

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

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

Matchstick

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

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

3D default

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

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Tetrahedral", 7}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Tetrahedral",7}]]

Default embedding

GraphPlot[Graph[GraphData[{"Tetrahedral",7},"VertexList"],GraphData[{"Tetrahedral",7},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

GraphData[{"Tetrahedral",7},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Tetrahedral",7},"Graph","IGraph"]//StyleGraphs

Bilateral

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

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Tetrahedral",7},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

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

Circular construction

GraphData[{"Tetrahedral",7},"Hamiltonian"]

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

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",7},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Tetrahedral",7},"V"]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",7},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",7}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",7},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Tetrahedral",7},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",7},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Tetrahedral",7},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",7},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

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

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",7}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",7},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",7}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",7},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

GraphData[{"Tetrahedral",7},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Tetrahedral",7}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Tetrahedral",7},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Tetrahedral",7},"ComplementGraph","Name"]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

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

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCF compute 10^7 [42 GB]

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCF compute 5*^7 [176 GB]

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCF compute all

Divisors[GraphData[{"Tetrahedral",7},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"Tetrahedral",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

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Tetrahedral", 8}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Tetrahedral",8}]]

Default embedding

GraphPlot[Graph[GraphData[{"Tetrahedral",8},"VertexList"],GraphData[{"Tetrahedral",8},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

GraphData[{"Tetrahedral",8},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Tetrahedral",8},"Graph","IGraph"]//StyleGraphs

Bilateral

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

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Tetrahedral",8},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

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

Circular construction

GraphData[{"Tetrahedral",8},"Hamiltonian"]

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

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",8},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Tetrahedral",8},"V"]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",8},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",8}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",8},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Tetrahedral",8},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",8},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Tetrahedral",8},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",8},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

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

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",8}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",8},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",8}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",8},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

GraphData[{"Tetrahedral",8},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Tetrahedral",8}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Tetrahedral",8},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Tetrahedral",8},"ComplementGraph","Name"]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

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

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCF compute 10^6

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Tetrahedral",8}],10^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]

gs

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

LCF compute all

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

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"Tetrahedral",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

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Tetrahedral", 9}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Tetrahedral",9}]]

Default embedding

GraphPlot[Graph[GraphData[{"Tetrahedral",9},"VertexList"],GraphData[{"Tetrahedral",9},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

GraphData[{"Tetrahedral",9},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Tetrahedral",9},"Graph","IGraph"]//StyleGraphs

Bilateral

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

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Tetrahedral",9},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

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

Circular construction

GraphData[{"Tetrahedral",9},"Hamiltonian"]

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

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",9},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Tetrahedral",9},"V"]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",9},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",9}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",9},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Tetrahedral",9},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",9},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Tetrahedral",9},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",9},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

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

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",9}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",9},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",9}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",9},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

GraphData[{"Tetrahedral",9},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Tetrahedral",9}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Tetrahedral",9},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Tetrahedral",9},"ComplementGraph","Name"]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

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

LCF compute 10^5

Tally[(lcf=LCF[GraphData[{"Tetrahedral",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]

gs

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

LCF compute all

Divisors[GraphData[{"Tetrahedral",9},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"Tetrahedral",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

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

{"Tetrahedral", 10}

Names

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

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

Primary

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

All

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

Inexact

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

Embedding types

GraphDataEmbeddings[GraphData[{"Tetrahedral",10}]]

Default embedding

GraphPlot[Graph[GraphData[{"Tetrahedral",10},"VertexList"],GraphData[{"Tetrahedral",10},"Edges"]]]

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

RecognizeGraph@g

Degenerate

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

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

GeneralizedPetersen

GraphData[{"Tetrahedral",10},"Graph","GeneralizedPetersen"]//StyleGraphs

IGraph

GraphData[{"Tetrahedral",10},"Graph","IGraph"]//StyleGraphs

Bilateral

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

Grid[DeleteCases[Monitor[{g=#,BilateralGraphEmbeddingTypes[#],GraphSymmetryGroup[#]}&/@GraphData[{"Tetrahedral",10},"Graph","All"],g],{_,_,TransformationGroup[{}]}],Dividers->All,Alignment->{{Center,{Left}}}]

Circular

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

Circular construction

GraphData[{"Tetrahedral",10},"Hamiltonian"]

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

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

Planar

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

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

MinimalCrossing

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

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

MinimalCrossing construction

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

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

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

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

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

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

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

faces=ReverseSort@SymmetricallyDistinctFaces[g]

Tally[ReverseSort[Length/@faces]]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",10},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Select[gs,Max[OuterFace[#]]<=GraphData[{"Tetrahedral",10},"V"]&]

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

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",10},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",10}],"CrossingNumber"->cn,RandomSeed->i],{i,50}]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",10},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

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

RecognizeGraph[g]

RectilinearCrossingCount[g]

RectilinearLocalCrossingCount[g]

MinimalLocalCrossing

GraphData[{"Tetrahedral",10},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",10},"Graph","MinimalLocalCrossing"]//StyleGraphs

MinimalRectilinearLocalCrossing

GraphData[{"Tetrahedral",10},{"LocalCrossingNumber","RectilinearLocalCrossingNumber"}]

GraphData[{"Tetrahedral",10},"Graph","MinimalRectilinearLocalCrossing"]//StyleGraphs

MinimaRectilinearlLocalCrossing construction

AdjacentCrossingsQ[g_Graph,cn_Integer]:=Module[{a=AdjacencyList[g],n=VertexCount[g]-cn},Max[Take[a,-cn]]>n]

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

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",10}],"CrossingNumber"->cn,RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",10},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

(gs=Select[Table[MinimalCrossingGraph[GraphData[{"Tetrahedral",10}],"CrossingNumber"->(cn=XXX),RandomSeed->i],{i,20000}],!AdjacentCrossingsQ[#,cn]&]//Union)//Timing

Select[gs,GraphSymmetryGroup[#,AdditionalData->Join[Table[True,GraphData[{"Tetrahedral",10},"V"]],Table[False,cn]],SameTest->Equal]=!=TransformationGroup[{}]&]

Circulant

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

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

Circulant construction

GraphData[{"Tetrahedral",10},"NotationRules","Circulant"]

(ci=CirculantIndices[GraphData[{"Tetrahedral",10}]])//Timing

CirculantGraph1@@@ci

Cases[GraphData[{"Tetrahedral",10},"StandardNames"],{"Circulant",i_}:>i]

CirculantGraph1@@@%

Complement graph

compl=GraphData[{"Tetrahedral",10},"ComplementGraph","Name"]

Line graph

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

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

RootGraph

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

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

RecognizeGraph[%]

Halin

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

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

Rigid

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

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

Flexible

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

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

LCF

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

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

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

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

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

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

LCF compute random

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

LCF compute 10^5

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

MaxMemoryUsed[]/10.^9 "GB"

DeleteCases[lcf,{_,1}]

LCF compute 10^6

Tally[(lcf=LCF[GraphData[{"Tetrahedral",10}],10^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]

gs

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

LCF compute 10^7

Tally[(lcf=LCF[GraphData[{"Tetrahedral",10}],10^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]

gs

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

LCF compute all

Divisors[GraphData[{"Tetrahedral",10},"V"]]

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

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

MaxMemoryUsed[]/10.^9 "GB"

Tally[(lcf=ReadProperty["LCFNotations",GraphNameToFileName[{"Tetrahedral",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

BilateralGraphEmbeddingQ/@gs

(nice=SelectFirst[lcf,GraphSymmetryGroup[LCFGraph@@#]=!=TransformationGroup[{}]&])//Timing

UnitDistance

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

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

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

UnitDistance by refinement

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

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

UnitDistance by FindUnitDistanceEmbedding

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

Matchstick

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

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

3D default

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

3D construction

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

RecognizeGraph[g]

3D All

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

3D UnitDistance

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

3D Polyhedron

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

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

GraphData

GraphDataClassString

GraphDataClassString["Tetrahedral"]