Adjacency Matrix

Author

Eric W. Weisstein
April 20, 2020

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

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

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

Figure

V6

Show[GraphicsArray[Graphics[{
ShowLabeledGraph[#,VertexStyle->Disk[.1],VertexColor->Red,
VertexNumberPosition->{-1,1}.04,DisplayFunction->Identity][[1]],
Text[MatrixForm[ToAdjacencyMatrix[#]],{.5,-.7}]
},AspectRatio->Automatic,PlotRange->All]&/@(Graphs[4][[#]]&/@{4,9,11})]]

V7

gs={"ClawGraph",{"Cycle",4},"TetrahedralGraph"};

mat=Normal[AdjacencyMatrix[GraphData[#]]]&/@gs

Options[AdjacencyGraph]

GraphicsGrid[{AdjacencyGraph[#,VertexLabels->"Name",VertexSize->Small,System`VertexStyle->Red,System`EdgeStyle->Black,PlotRangePadding->.2]&/@mat,TraditionalForm/@(Style[#,14]&/@mat)}]

Isomorphic

(Subscript[C, 4])

aut=GraphData["C4","AutomorphismGroup"]

{GraphData["C4","AutomorphismCount"],GroupOrder[aut]}

4!/8

mat=AllAdjacencyMatrices[GraphData["C4"]]

GraphicsGrid[{AdjacencyGraph[#,VertexLabels->"Name",VertexSize->Small,System`VertexStyle->Red,System`EdgeStyle->Black,PlotRangePadding->.2]&/@mat,TraditionalForm/@(Style[#,14]&/@mat)}]

(Subscript[P, 3])

GraphData["P3","AutomorphismCount"]

3!/2

RightTransversal[aut,System`SymmetricGroup[3]]

PermutationList[#,3]&/@%

RightTransversal[aut,System`SymmetricGroup[3]]

PermutationList[#,3]&/@%

mat=AllAdjacencyMatrices[GraphData["P3"]]

PermutationList[#,3]&/@%

Permutations[Range[3]]

Union[Sort[{#, #[[{3, 2, 1}]]}][[1]]&/@%10]

RightTransversal[aut,System`SymmetricGroup[3]]

PermutationList[#,3]&/@%

(Subscript[P, 4])

a1={{0,1,0,0},{1,0,1,0},{0,1,0,1},{0,0,1,0}};
a2={{0,0,0,1},{0,0,1,1},{0,1,0,0},{1,1,0,0}};

RecognizeGraph/@AdjacencyGraph/@{a1,a2}

p=With[{g="P4"},PermutationList[#,GraphData[g,"V"]]&/@GroupElements[GraphData[g,"AutomorphismGroup"]]]

EdgeList[AdjacencyGraph[a1]]

Union[Sort/@Position[a1,1]]

EdgeList[AdjacencyGraph[a2]]

Union[Sort/@Position[a2,1]]

MatrixForm/@(mats=AllAdjacencyMatrices[GraphData["P4"]])

RecognizeGraph/@AdjacencyGraph/@mats

Bandwidth[m_List]:=Max[Abs[Subtract@@@Position[m,1]]]
Bandwidth[g_System`Graph]:=Min[Bandwidth/@AllAdjacencyMatrices[g]]

Bandwidth/@mats

Bandwidth[GraphData["P4"]]//Timing

Bandwidth[GraphData["P4"],GraphData["P4","AutomorphismGroup"]/.Combinatorica`Cycles->System`Cycles]//Timing

(Subscript[Q, 3])

aut=GraphData["Q3","AutomorphismGroup"]

{GraphData["Q3","AutomorphismCount"],GroupOrder[aut]}

rt=RightTransversal[aut,System`SymmetricGroup[8]];//Timing

Length[rt]

Length[mat=AllAdjacencyMatrices[GraphData["Q3"]]]//Timing

Length[pairs=AllPairs[GraphData["Q3"]]]//Timing

{8!,GraphData["Q3","V"]!/840}

MatrixForm/@Take[AllAdjacencyMatrices[GraphData["Q3"]],10]

Bandwidth[GraphData["Q3"]]//Timing

Bandwidth[GraphData["Q3"],GraphData["Q3","AutomorphismGroup"]/.Combinatorica`Cycles->System`Cycles]//Timing

Bandwidth[GraphData["Q3"],GraphData["Q3","AutomorphismGroup"]/.Combinatorica`Cycles->System`Cycles]//Timing

(Subscript[Q, 4])

GraphData["Q4","V"]

Bandwidth[GraphData["Q4"]]//Timing

Bandwidth[GraphData["Q4"],GraphData["Q4","AutomorphismGroup"]/.Cycles->System`Cycles]//Timing

TriakisTetrahedralGraph

Bandwidth[GraphData["TriakisTetrahedralGraph"]]//Timing

Bandwidth[GraphData["TriakisTetrahedralGraph"],GraphData["TriakisTetrahedralGraph","AutomorphismGroup"]/.Cycles->System`Cycles]//Timing

Bandwidth[GraphData["TriakisTetrahedralGraph"],GraphData["TriakisTetrahedralGraph","AutomorphismGroup"]/.Cycles->System`Cycles]//Timing

Bandwidth[GraphData["TriakisTetrahedralGraph"],GraphData["TriakisTetrahedralGraph","AutomorphismGroup"]/.Cycles->System`Cycles]//Timing

Formula

((VertexCount[g]!)/(GroupOrder[GraphAutomorphismGroup[g]]))

Parametrized families

GraphDataCountTable["AdjacencyMatrixCount"]

Andrasfai

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

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

Antelope n×n

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

(seq=Table[GroupOrder@GraphAutomorphismGroup[AntelopeGraph[n,n]],{n,30}])//Timing

Antiprism

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

seq=Table[GraphData[{"Antiprism",n},"AdjacencyMatrixCount"],{n,3,25}]

Table[Piecewise[{{15, n == 3}}, Gamma[2n]/2],{n,3,25}]==seq

FindSequenceFunction[Rest@seq,n-3]

FullSimplify[%]

Apollonian

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

FindSequenceFunction[seq,n]

(seq=Table[GroupOrder@GraphAutomorphismGroup[ApollonianGraph[n]],{n,8}])//Timing

Barbell

seq=Table[GraphData[{"Barbell",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

Bishop n×n

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

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

BlackBishop n×n

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

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

Book

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

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

Bruhat

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

FindSequenceFunction[seq,n]

FindSequenceFunction[Rest@seq,n]

(seq=Table[GroupOrder@GraphAutomorphismGroup[BruhatGraph[n]],{n,7}])//Timing

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

Centipede

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

CocktailParty

seq=Table[GraphData[{"CocktailParty",n},"AdjacencyMatrixCount"],{n,20}]

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

Complete

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

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

seq=Table[GraphData[{"Complete",n},"AdjacencyMatrixCount"],{n,20}]

FindSequenceFunction[seq,n]

CompleteBipartite m×n

Entity["Graph",{"CompleteBipartite",{m,n}}]["AdjacencyMatrixCount"]

DeleteCases[Flatten[Table[{
{k,m,n},
GraphData[{"CompleteBipartite",{m,n}},"AdjacencyMatrixCount"],
Piecewise[{{(1/2)*Binomial[2*n, n], m == n}}, Binomial[m + n, n]]
},{m,5},{n,m,5}],1],{_,x_,x_}]

CompleteBipartite n×n

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

seq=Table[GraphData[{"CompleteBipartite",{n,n}},"AdjacencyMatrixCount"],{n,20}]

FindSequenceFunction[seq,n]//FullSimplify

expr1=(1/2) Binomial[2 n,n];

expr2=(((4^(-1+n)) Pochhammer[(3/2),-1+n])/(Gamma[1+n]));

SimplifyCount/@{expr1,expr2}

FullSimplify[expr2]===expr2

FullSimplify[expr1-expr2]

FunctionExpand[%]

FullSimplify[%]

expr1=

CompleteTripartite k×m×n

Entity["Graph",{"CompleteTripartite",{k,m,n}}]["AdjacencyMatrixCount"]

Table[GraphData[{"CompleteTripartite",{k,m,n}},"AdjacencyMatrixCount"],{k,5},{m,k,5},{n,m,5}]//Column//TraditionalForm

DeleteCases[Flatten[Table[{
{k,m,n},
GraphData[{"CompleteTripartite",{k,m,n}},"AdjacencyMatrixCount"],
Multinomial[k, m, n]/Piecewise[{{3, k == m == n}, {2, k == m || m == n || n == k}}, 1]!
},{k,5},{m,k,5},{n,m,5}],2],{_,x_,x_}]

CompleteTripartite n×n×n

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

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

bug(392008): FullSimplify[Gamma[3 n]/(2 Gamma[n] Gamma[1 + n]^2)] could return Multinomial[n, n, n]/6 (FullSimplify of difference returns 0)

FindSequenceFunction[seq,n]//FullSimplify

FunctionExpand[%]

expr1=(1/6) Multinomial[n,n,n];

expr2=((Gamma[3 n])/(2 Gamma[n] ((Gamma[1+n])^2)))

SimplifyCount/@{expr1,expr2}

FullSimplify[expr2]===expr2

FullSimplify[expr1-expr2]

CrossedPrism

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

FindSequenceFunction[Rest@seq,n-2]

Crown

seq=Table[GraphData[{"Crown",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

CubeConnectedCycle

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

(seq=Table[GraphData[{"CubeConnectedCycle",n},"AdjacencyMatrixCount"],{n,3,8}])//Take[#,4]&

FindSequenceFunction[seq,n-2]//Head

Table[(1/2) Gamma[(2^n) n],{n,3,8}]==seq

Cycle

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

seq=Table[GraphData[{"Cycle",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//FullSimplify

DiagonalIntersection

seq=Table[GraphData[{"DiagonalIntersection",n},"AdjacencyMatrixCount"],{n,3,14}]

Dipyramid

seq=Table[GraphData[{"Dipyramid",n},"AdjacencyMatrixCount"],{n,3,14}]

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

Empty

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

seq=Table[GraphData[{"Empty",n},"AdjacencyMatrixCount"],{n,30}]

FindSequenceFunction[seq,n]

FibonacciCube

seq=Table[GraphData[{"FibonacciCube",n},"AdjacencyMatrixCount"],{n,15}]

Fiveleaper n×n

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

(seq=Table[GroupOrder@GraphAutomorphismGroup[FiveleaperGraph[n,n]],{n,20}])//Timing

FoldedCube

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

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

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

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

Gear

seq=Table[GraphData[{"Gear",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

GeneralizedPetersen

DeleteCases[Sort[{"GeneralizedPetersen"/.GraphData[#,"NotationRules"],GraphData[#,"AdjacencyMatrixCount"]}&/@GraphData["GeneralizedPetersen"]],{_,0}]

Table[{{n,k},If[k>2&&Mod[n,k]==0,k/(2n),0],AutomorphismCount@PetersenGraph[n,k]},{n,2,10},{k,n/2-1}]

Grid 3×n

Entity["Graph",{"Grid",{3,n}}]["AdjacencyMatrixCount"]

seq=Table[GraphData[{"Grid",Sort[{3,n}]},"AdjacencyMatrixCount"],{n,10}]

Grid m×n

Entity["Graph",{"Grid",{m,n}}]["AdjacencyMatrixCount"]

DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"Grid",{m,n}},"AdjacencyMatrixCount"],
(m n)!/Piecewise[{{1,m==n==1},{2,Min[m,n]==1},{8,m==n}},4]
},{m,5},{n,m,5}],1],{_,x_,x_}]

DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"Grid",{m,n}},"AdjacencyMatrixCount"],
Piecewise[{{1,m==n==1},{Max[m,n]!/2,Min[m,n]==1},{(m n)!/8,m==n}},(m n)!/4]
},{m,5},{n,m,5}],1],{_,x_,x_}]

Grid n×n

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

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

FindSequenceFunction[Rest@seq,n-1]

Table[Piecewise[{{1,n==1}},(n^2)!/8],{n,10}]==seq

Grid k×m×n

Entity["Graph",{"Grid",{k,m,n}}]["AdjacencyMatrixCount"]

DeleteCases[Flatten[Table[{
{k,m,n},
GraphData[{"Grid",{k,m,n}},"AdjacencyMatrixCount"],
Piecewise[{
{1,k==m==n==1},
{Max[k m n]!/2,k m n==Max[k,m,n]},
{(k m n)!/4,Min[k,m,n]==1&&k m n≠Max[k,m,n]^2},
{(n^3)!/48, k == m == n},
 {(k m n)!/16,Min[k,m,n]>1&&(k == m || m == n || k == n)}
},(k m n)!/ 8]
},{k,5},{m,k,5},{n,m,5}],2],{_,x_,x_}]

Grid n×n×n

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

(seq=Table[GraphData[{"Grid",{n,n,n}},"AdjacencyMatrixCount"],{n,10}])//Take[#,4]&

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

Table[Piecewise[{{1,n==1}},(n^3)!/48],{n,10}]==seq

Grid

AutomorphismCount[GridGraph[RandomInteger[{1,10},#]]]&/@RandomInteger[{1,4},100]//Union

HalvedCube

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

FindSequenceFunction[Drop[seq,4],n-4]//FullSimplify

Hanoi

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

FindSequenceFunction[seq,n]//FullSimplify

Helm

seq=Table[GraphData[{"Helm",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

Hypercube

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

(seq=Table[GraphData[{"Hypercube",n},"AdjacencyMatrixCount"],{n,0,10}])//Take[#,6]&

FindSequenceFunction[seq,n+1]

Table[((Gamma[(2^n)])/(n!)),{n,0,10}]==seq

Keller

A051189 (starting with term 3)

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

(seq=Table[GraphData[{"Keller",n},"AdjacencyMatrixCount"],{n,5}])//Take[#,4]&

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

seq={24,1920,3072,98304,3932160,188743680};

Do[Print[{k,Head@FindSequenceFunction[Drop[seq,k],n-k]}],{k,0,3}]

{MaxMemoryUsed[keller7=KellerGraph[7]],ByteCount[keller7]}/1.*^9GB//Timing

Through[{Head,VertexCount,EdgeCount}[keller7]]

{MaxMemoryUsed[aut7=GroupOrder@GraphAutomorphismGroup[keller7]],ByteCount[aut7]}//Timing

aut7

seq={24,1920,3072,98304,3932160,188743680,10569646080};

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

Table[(4^n)!/Piecewise[{{24,n==1},{1920,n==2}},(8^n)n!],{n,5}]==seq

King m×n

Table[GraphData[{"King",{m,n}},"AdjacencyMatrixCount"],{n,10},{m,n}]//Column//TraditionalForm

DeleteCases[Flatten[Table[{
{m,n},
Piecewise[{{1,m==n==1},{24,m==n==2},{2,Min[m,n]==1},{8,m==n},{(2^(Max[m,n]+1)),Min[m,n]==2}},4],
GraphData[{"King",{m,n}},"AdjacencyMatrixCount"]
},{n,10},{m,n}],1],{_,x_,x_}]

King 2×n

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

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

King n×n

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

Knight m×n

Entity["Graph",{"Knight",{m,n}}]["AdjacencyMatrixCount"]

InputForm[%]

Table[GraphData[{"Knight",{m,n}},"AdjacencyMatrixCount"],{n,10},{m,n}]//Column//TraditionalForm

DeleteCases[Flatten[Table[{
{m,n},
(m*n)!/Piecewise[{{Max[m,n]!,Min[m,n]==1},{24,m==n==2},{16,m==n==3||(Min[m,n]==2&&Max[m,n]==3)||(Min[m,n]==3&&Max[m,n]==6)},{64,m==n==4||(Min[m,n]==2&&Mod[Max[m,n],2]==1)},{8,m==n||(Min[m,n]==3&&(Max[m,n]==5||Max[m,n]==7))},{384,Min[m,n]==2&&Mod[Max[m,n],2]==0}},4],
GraphData[{"Knight",{m,n}},"AdjacencyMatrixCount"]
},{n,10},{m,n}],1],{_,x_,x_}]

Knight n×n

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

(seq=Table[GraphData[{"Knight",{n,n}},"AdjacencyMatrixCount"],{n,20}])//Take[#,5]&

Ladder

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

seq=Table[GraphData[{"Ladder",n},"AdjacencyMatrixCount"],{n,20}]

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

FullSimplify[%]

LadderRung

seq=Table[GraphData[{"LadderRung",n},"AdjacencyMatrixCount"],{n,20}]

FindSequenceFunction[seq,n]

FullSimplify[%]

FunctionExpand[%]

MengerSponge

seq=Table[GraphData[{"MengerSponge",n},"AdjacencyMatrixCount"],{n,3}]

MoebiusLadder

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

InputForm[%]

(seq=Table[GraphData[{"MoebiusLadder",n},"AdjacencyMatrixCount"],{n,3,25}])//Take[#,5]&

FindSequenceFunction[Rest@seq,n-3]

FullSimplify[%]

Table[Piecewise[{{10,n==3}},Gamma[2*n]/2],{n,3,25}]==seq

Mycielski

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

InputForm[%]

(seq=Table[GraphData[{"Mycielski",n},"AdjacencyMatrixCount"],{n,11}])//Take[#,4]&

Table[Piecewise[{{1,n==1||n==2}},Gamma[3*2^(-2+n)]/10],{n,11}]==seq

Odd

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

(seq=Table[GraphData[{"Odd",n},"AdjacencyMatrixCount"],{n,7}])//Take[#,5]&

FindSequenceFunction[seq,n]//Head

Table[Binomial[-1+2*n,-1+n]!/Gamma[2*n],{n,7}]==seq

Pan

seq=Table[GraphData[{"Pan",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

FullSimplify[%]

Path

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

seq=Table[GraphData[{"Path",n},"AdjacencyMatrixCount"],{n,20}]

FindSequenceFunction[Rest@seq,n-1]

FullSimplify[%]

PathComplement

seq=Table[GraphData[{"PathComplement",n},"AdjacencyMatrixCount"],{n,20}]

Prism

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

(seq=Table[GraphData[{"Prism",n},"AdjacencyMatrixCount"],{n,3,25}])//Take[#,5]&

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

FullSimplify[%]

Table[Piecewise[{{840,n==4}},(1/2) Gamma[2 n]],{n,3,25}]==seq

Queen m×n

Table[GraphData[{"Queen",{m,n}},"AdjacencyMatrixCount"],{n,10},{m,n}]//Column//TraditionalForm

DeleteCases[Flatten[Table[{
{m,n},
Piecewise[{{Max[m, n]!, Min[m, n] == 1},{24, m == n == 2},{16,Max[m,n]==3},{8,m==n||(Min[m,n]==2&&Max[m,n]==4)}}, 4],
GraphData[{"Queen",{m,n}},"AdjacencyMatrixCount"]
},{n,10},{m,n}],1],{_,x_,x_}]

Queen n×n

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

Rook m×n

Table[GraphData[{"Rook",{m,n}},"AdjacencyMatrixCount"],{n,10},{m,n}]//Column//TraditionalForm

DeleteCases[Flatten[Table[{
{m,n},
Piecewise[{{Max[m, n]!, Min[m, n] == 1}}, XXX],
GraphData[{"Queen",{m,n}},"AdjacencyMatrixCount"]
},{n,10},{m,n}],1],{_,x_,x_}]

Rook n×n

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

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

RookComplement n×n

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

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

SierpinskiCarpet

seq=Table[GraphData[{"SierpinskiCarpet",n},"AdjacencyMatrixCount"],{n,4}]

SierpinskiSieve

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

SierpinskiTetrahedron

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

StackedBook m×n

Table[GraphData[{"StackedBook",{m,n}},"AdjacencyMatrixCount"],{m,10},{n,10}]//Column//TraditionalForm

FindSequenceFunction[{4,12,48,240,1440},n-1]

DeleteCases[Flatten[Table[{
{m,n},
Piecewise[{{2,m==n==1},{8,(m==1&&n==2)||(m==2&&n==3)},{4,m==1},{m!,n == 1}},2m!],
GraphData[{"StackedBook",{m,n}},"AdjacencyMatrixCount"]
},{n,10},{m,10}],1],{_,x_,x_}]

StackedBook n×n

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

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

Star

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

seq=Table[GraphData[{"Star",n},"AdjacencyMatrixCount"],{n,25}]

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

Sun

seq=Table[GraphData[{"Sun",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]//Factor

Sunlet

seq=Table[GraphData[{"Sunlet",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

Tetrahedral

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

FindSequenceFunction[seq,n-5]//Head

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

FindSequenceFunction[Drop[seq,1],n-6]//FullSimplify

Transposition

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

(seq=Table[GraphData[{"Transposition",n},"AdjacencyMatrixCount"],{n,6}])//Take[#,5]&

Table[(n!)!/Piecewise[{{1,n==1},{2,n==2}},2*n!^2],{n,6}]==seq

Triangular

seq=Table[GraphData[{"Triangular",n},"AdjacencyMatrixCount"],{n,2,20}]

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

TriangularGrid

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

TriangularHoneycombAcuteKnight

seq=Table[GraphData[{"TriangularHoneycombAcuteKnight",n},"AdjacencyMatrixCount"],{n,20}]

TriangularHoneycombBishop

seq=Table[GraphData[{"TriangularHoneycombBishop",n},"AdjacencyMatrixCount"],{n,9}]

TriangularHoneycombObtuseKnight

seq=Table[GraphData[{"TriangularHoneycombObtuseKnight",n},"AdjacencyMatrixCount"],{n,20}]

TriangularHoneycombQueen

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

TriangularHoneycombRook

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

FindSequenceFunction[seq,n]

TriangularSnake

seq=Table[GraphData[{"TriangularSnake",n},"AdjacencyMatrixCount"],{n,1,20,2}]

Web

seq=Table[GraphData[{"Web",n},"AdjacencyMatrixCount"],{n,3,20}]

FindSequenceFunction[seq,n-2]

Wheel

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

seq=Table[GraphData[{"Wheel",n},"AdjacencyMatrixCount"],{n,4,20}]

FindSequenceFunction[Drop[seq,1],n-4]//Factor

FullSimplify[%]

WhiteBishop n×n

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

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