Bicirculant Graph

Author

Eric W. Weisstein
May 28, 2026

This notebook downloaded from https://mathworld.wolfram.com/notebooks/GraphTheory/BicirculantGraph.nb.

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

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

Example

g=Graph[UndirectedEdge@@@{{1,2},{1,22},{2,3},{3,4},{4,5},{5,6},{6,7},{7,8},{8,9},{9,10},{10,11},{11,12},{12,13},{13,14},{14,15},{15,16},{16,17},{17,18},{18,19},{19,20},{20,21},{21,22},{2,6},{2,20},{4,8},{4,22},{6,10},{8,12},{10,14},{12,16},{14,18},{16,20},{18,22},{1,9},{1,15},{3,11},{3,17},{5,13},{5,19},{7,15},{7,21},{9,17},{11,19},{13,21}},VertexCoordinates->Thread[Range[22]->CirclePoints[22]]]

BicirculantGraphQ[g,Debug->True]

GraphDataCountTable

table=GraphDataCountTable["Bicirculant"]

DateString[]

TextGrid[OEISUpdates[table],Dividers->All]

Parametrized families

<<MathWorld`Graphs`

Alkane

seq=Table[GraphData[{"Alkane",n},"Bicirculant"],{n,10}]

AlternatingGroupGraph

seq=Table[GraphData[{"AlternatingGroupGraph",n},"Bicirculant"],{n,2,6}]

Andrasfai

seq=Table[GraphData[{"Andrasfai",n},"Bicirculant"],{n,20}]

Antelope n×n

seq=Table[GraphData[{"Antelope",{n,n}},"Bicirculant"],{n,20}]

Antelope m×n

DeleteCases[
Flatten[Table[{
{m,n},
GraphData[{"Antelope",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}
]//Quiet

Antiprism

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

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

Apollonian

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

Barbell

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

Bishop n×n

seq=Table[GraphData[{"Bishop",{n,n}},"Bicirculant"],{n,20}]

Bishop m×n

Entity["Graph",{"Bishop",{m,n}}]["Bicirculant"]

DeleteCases[
Flatten[Table[{
{m,n},
GraphData[{"CompleteBipartite",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

BlackBishop n×n

seq=Table[GraphData[{"BlackBishop",{n,n}},"Bicirculant"],{n,20}]

BlackBishop m×n

Entity["Graph",{"Bishop",{m,n}}]["Bicirculant"]

DeleteCases[
Flatten[Table[{
{m,n},
GraphData[{"BlackBishop",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}
]//Quiet

Book

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

Bruhat

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

Camel n×n

seq=Table[GraphData[{"Camel",{n,n}},"Bicirculant"],{n,20}]

Camel m×n

Entity["Graph",{"Camel",{m,n}}]["Bicirculant"]

DeleteCases[
Flatten[Table[{
{m,n},
GraphData[{"CompleteBipartite",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Cameron

seq=Table[GraphData[{"Cameron",n},"Bicirculant"],{n,20}]

Centipede

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

CocktailParty

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

Complete

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

seq=Table[GraphData[{"Complete",n},"Bicirculant"],{n,30}]

CompleteBipartite n×n

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

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

CompleteBipartite m×n

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

DeleteCases[
Flatten[Table[{
{m,n},
GraphData[{"CompleteBipartite",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

CompleteTripartite n×n×n

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

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

CompleteTripartite k×m×n

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

DeleteCases[
Flatten[Table[{
{k,m,n},
GraphData[{"CompleteTripartite",{k,m,n}},"Bicirculant"],
XXX
},{n,10},{m,n},{k,m}],2],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

CompleteTripartiteMinusPerfectMatching

seq=Table[GraphData[{"CompleteTripartiteMinusPerfectMatching",{2n,2n,2n}},"Bicirculant"],{n,10}]

CossidentePenttila

{
#,
q=GraphData[#,"NotationRules","CossidentePenttila"],
XXX,
GraphData[#,"Bicirculant"]
}&/@GraphData["CossidentePenttila"]

CrossedPrism

seq=Table[GraphData[{"CrossedPrism",2n},"Bicirculant"],{n,2,12}]

Crown

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

CubeConnectedCycle

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

seq=Table[GraphData[{"CubeConnectedCycle",n},"Bicirculant"],{n,3,8}]

Cycle

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

seq=Table[GraphData[{"Cycle",n},"Bicirculant"],{n,3,30}]

CycleComplement

seq=Table[GraphData[{"CycleComplement",n},"Bicirculant"],{n,3,20}]

DiagonalIntersection

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

Dipyramid

seq=Table[GraphData[{"Dipyramid",n},"Bicirculant"],{n,3,20}]

DorogovtsevGoltsevMendes

seq=Table[GraphData[{"DorogovtsevGoltsevMendes",n},"Bicirculant"],{n,0,7}]

DoubleCone

seq=Table[GraphData[{"DoubleCone",n},"Bicirculant"],{n,3,20}]

Empty

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

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

ErectedPolygon

DeleteCases[Module[{n,r},
{
#,
{n,r}=GraphData[#,"NotationRules","ErectedPolygon"],
XXX,
GraphData[#,"Bicirculant"]
}
]&/@GraphData["ErectedPolygon"],
{__,x_,x_}]

FibonacciCube

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

Fiveleaper n×n

seq=Table[GraphData[{"Fiveleaper",{n,n}},"Bicirculant"],{n,20}]

Fiveleaper m×n

Entity["Graph",{"Fiveleaper",{m,n}}]["Bicirculant"]

DeleteCases[
Flatten[Table[{
{m,n},
GraphData[{"Fiveleaper",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Flower

seq=Table[GraphData[{"Flower",n},"Bicirculant"],{n,5,20}]

FoldedCube

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

Gear

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

Giraffe n×n

seq=Table[GraphData[{"Giraffe",{n,n}},"Bicirculant"],{n,20}]

Giraffe m×n

Entity["Graph",{"Fiveleaper",{m,n}}]["Bicirculant"]

DeleteCases[
Flatten[Table[{
{m,n},
GraphData[{"Giraffe",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Goldberg

seq=Table[GraphData[{"Goldberg",n},"Bicirculant"],{n,3,20}]

Grid n×n

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

seq=Table[GraphData[{"Grid",{n,n}},"Bicirculant"],{n,20}]

Grid m×n

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

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"Grid",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Grid n×n×n

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

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

Grid k×m×n

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

Sort@DeleteCases[Flatten[Table[{
{k,m,n},
GraphData[{"Grid",{k,m,n}},"Bicirculant"],
XXX
},{n,10},{m,n},{k,m}],2],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

HalvedCube

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

Hanoi

seq=Table[GraphData[{"Hanoi",n},"Bicirculant"],{n,6}]

Helm

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

Hypercube

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

seq=Table[GraphData[{"Hypercube",n},"Bicirculant"],{n,0,10}]

ChatGPT 5.5 Heavy thinking

Plan: interpret `nQ_3` as the disjoint union of `n` copies of the cubical graph `Q_3`, then give an explicit two-orbit cyclic automorphism.

**Yes**, under the usual non-connected bicirculant convention.

MathWorld notes that `nG` denotes the disjoint union of `n` copies of `G`, and that the cubical graph is `Q_3`. It also gives the convention that a bicirculant has a cyclic symmetry with exactly two equal group orbits. ([MathWorld][1])

Use vertices

```wl
{i, x, y, z}
```

where `i = 0, ..., n - 1` indexes the copy and `{x, y, z}` is a vertex of `Q_3`.

On `Q_3`, define

```wl
r[{x_, y_, z_}] := {y, Mod[x + 1, 2], z}
```

This is a cube automorphism with two 4-cycles:

```wl
{{0, 0, z}, {0, 1, z}, {1, 1, z}, {1, 0, z}}
```

for `z = 0, 1`.

Now define an automorphism of `nQ_3` by shifting copies, applying `r` only at wraparound:

```wl
phi[{i_, x_, y_, z_}] :=
  If[i < n - 1,
    {i + 1, x, y, z},
    {0, Sequence @@ r[{x, y, z}]}
  ]
```

Then `phi^n` acts as `r` inside each original copy, so `phi` has exactly two vertex orbits, each of size `4 n`. Therefore:

```wl
nQ3BicirculantQ[n_Integer?Positive] := True
```

Caveat: if a source requires bicirculants to be connected, then `nQ_3` is excluded for `n > 1` by disconnectedness. Under the MathWorld-style orbit definition, it is bicirculant for every positive `n`.

[1]: https://mathworld.wolfram.com/GraphUnion.html?utm_source=chatgpt.com "Graph Union -- from Wolfram MathWorld"

KC

DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"KC",{m,n}},"Bicirculant"],
XXX
},{n,3,10},{m,10}],1],{_,x_,x_}]

Keller

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

seq=Table[GraphData[{"Keller",n},"Bicirculant"],{n,5}]

King n×n

seq=Table[GraphData[{"King",{n,n}},"Bicirculant"],{n,20}]

King m×n

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"King",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Knight n×n

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

seq=Table[GraphData[{"Knight",{n,n}},"Bicirculant"],{n,20}]

Knight m×n

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

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"King",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

KP

DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"KP",{m,n}},"Bicirculant"],
XXX
},{n,10},{m,10}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Ladder

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

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

LadderRung

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

GraphData["LadderRung","Bicirculant"]

ChatGPT Pro 5.5 Heavy thinking

Yes, with the usual meaning of **bicirculant**. The (n)-ladder rung graph is (nP_2), i.e. the graph union of (n) copies of (P_2). MathWorld states this explicitly for the ladder rung graph, and Wolfram docs list `"LadderRung"` as “graph union of n two-paths.” ([MathWorld][1]) ([reference.wolfram.com][2])

A bicirculant has a cyclic symmetry with exactly two equal vertex orbits; MathWorld’s circulant page states this convention directly. ([MathWorld][3])

Label the vertices

```wl
u[0], ..., u[n - 1], v[0], ..., v[n - 1]
```

with edges

```wl
UndirectedEdge[u[i], v[i]]
```

for `i = 0, ..., n - 1`. Then the permutation

```wl
u[i] -> u[Mod[i + 1, n]]
v[i] -> v[Mod[i + 1, n]]
```

preserves all edges and has exactly two orbits, the `u` vertices and the `v` vertices, each of length `n`.

So mathematically:

```wl
GraphData[{"LadderRung", n}]
```

is bicirculant for all positive `n`, under the non-connected/degree-1-inclusive definition of bicirculant.

Caveat: if a source defines bicirculants only among **connected** regular graphs, then `nP_2` is connected only for `n == 1`; for `n > 1` it would be excluded by that extra convention, not by failure of the two-orbit cyclic symmetry.

[1]: https://mathworld.wolfram.com/LadderRungGraph.html "Ladder Rung Graph -- from Wolfram MathWorld"
[2]: https://reference.wolfram.com/language/ref/GraphData.html?utm_source=chatgpt.com "GraphData - Wolfram Language Documentation"
[3]: https://mathworld.wolfram.com/CirculantGraph.html "Circulant Graph -- from Wolfram MathWorld"

LindgrenSousselier

seq=Table[GraphData[{"LindgrenSousselier",n},"Bicirculant"],{n,11}]

LucasCube

seq=Table[GraphData[{"LucasCube",n},"Bicirculant"],{n,15}]

MengerSponge

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

MoebiusLadder

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

seq=Table[GraphData[{"MoebiusLadder",n},"Bicirculant"],{n,3,25}]

Mycielski

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

seq=Table[GraphData[{"Mycielski",n},"Bicirculant"],{n,11}]

Necklace

seq=Table[GraphData[{"Necklace",n},"Bicirculant"],{n,10}]

Odd

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

seq=Table[GraphData[{"Odd",n},"Bicirculant"],{n,7}]

Paley

{
#,
q=GraphData[#,"NotationRules","Paley"],
XXX,
GraphData[#,"Bicirculant"]
}&/@GraphData["Paley"]

Pan

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

Path

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

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

PathComplement

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

Peisert

{
#,
q=GraphData[#,"NotationRules","Peisert"],
XXX,
GraphData[#,"Bicirculant"]
}&/@GraphData["Peisert"]

Pell

seq=Table[GraphData[{"Pell",n},"Bicirculant"],{n,9}]

PlummerToft

seq=Table[GraphData[{"PlummerToft",n},"Bicirculant"],{n,20}]

Prism

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

seq=Table[GraphData[{"Prism",n},"Bicirculant"],{n,3,25}]

Queen n×n

seq=Table[GraphData[{"Queen",{n,n}},"Bicirculant"],{n,20}]

Queen m×n

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"Queen",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Rook n×n

seq=Table[GraphData[{"Rook",{n,n}},"Bicirculant"],{n,20}]

ChatGPT Pro 5.5 Heavy thinking

Plan: use `GraphData[{"Rook", {n, n}}] == K_n □ K_n`, then classify possible two-orbit cyclic automorphisms.

**Answer:** the `n x n` rook graph is bicirculant **iff**

```wl
n == 2 || n == 4
```

MathWorld identifies the `m x n` rook graph as `K_m □ K_n`, implemented in Wolfram Language as `GraphData[{"Rook", {m, n}}]`; for `m == n`, this is the square rook graph on `n^2` vertices. ([MathWorld][1]) MathWorld’s circulant entry states the convention I am using: a bicirculant graph has a cyclic symmetry with exactly two equal vertex orbits. ([MathWorld][2])

For `n >= 3`, automorphisms of `K_n □ K_n` permute the row and column cliques, either preserving the row/column classes or swapping them.

* If an automorphism preserves rows and columns, it has the form

```wl
{i, j} |-> {sigma[i], tau[j]}
```

A product of an `a`-cycle of `sigma` and a `b`-cycle of `tau` contributes `GCD[a, b]` vertex cycles. The only way to get exactly two equal vertex orbits is the small case `n == 2`.

* If an automorphism swaps rows and columns, after relabeling it has the form

```wl
{i, j} |-> {pi[j], i}
```

If `pi` has more than one cycle, there are already at least three vertex orbits. Thus `pi` must be an `n`-cycle. Then the induced vertex cycles have:

* for odd `n`: one orbit of length `n` and `(n - 1)/2` orbits of length `2 n`;
* for even `n`: `n/2` orbits, each of length `2 n`.

Exactly two equal orbits therefore requires `n/2 == 2`, hence `n == 4`.

Explicit witnesses:

```wl
rookBicirculantQ[n_Integer?Positive] := n == 2 || n == 4
```

For `n == 2`, use

```wl
{i_, j_} :> Mod[{i, j} + {1, 1}, 2]
```

with two orbits `{ {0,0}, {1,1} }` and `{ {0,1}, {1,0} }`.

For `n == 4`, use

```wl
{i_, j_} :> {Mod[j + 1, 4], i}
```

which has two orbits of length `8`.

So this is a mathematical inference from the rook graph structure and the bicirculant definition, not a sampled `GraphData` property value.

[1]: https://mathworld.wolfram.com/RookGraph.html "Rook Graph -- from Wolfram MathWorld"
[2]: https://mathworld.wolfram.com/CirculantGraph.html "Circulant Graph -- from Wolfram MathWorld"

Rook m×n

rookBicirculantQ[m_Integer?Positive,n_Integer?Positive]:=Which[m==n,m==2||m==4,True,Mod[m n,2]==0&&GCD[m,n]<=2]

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"Rook",{m,n}},"Bicirculant"],
rookBicirculantQ[m,n]
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

ChatGPT Pro 5.5 Heavy thinking

Assuming “bicurculant” means **bicirculant**:

```wl
rookBicirculantQ[m_Integer?Positive, n_Integer?Positive] :=
  Which[
    m == n, m == 2 || m == 4,
    True, Mod[m n, 2] == 0 && GCD[m, n] <= 2
  ]
```

So the `m x n` rook graph is bicirculant exactly when

```text
m != n and m n is even and GCD[m,n] <= 2
```

or in the square case exactly when

```text
m == n == 2 or m == n == 4.
```

**Provenance/conventions.** MathWorld defines the `m x n` rook graph as the Cartesian product `K_m` with `K_n`, equivalently the line graph of `K_{m,n}`, and says it is implemented as `GraphData[{"Rook", {m, n}}]`. It also states the bicirculant convention used here: a bicirculant has a cyclic symmetry with exactly two equal vertex orbits. ([MathWorld][1]) ([MathWorld][2])

**Why.** For `m != n`, automorphisms have the form

```wl
{i, j} |-> {sigma[i], tau[j]}
```

up to relabeling rows and columns. If `sigma` has cycle lengths `a_i` and `tau` has cycle lengths `b_j`, then each pair of cycles contributes `GCD[a_i,b_j]` vertex orbits. Requiring exactly two equal orbits gives precisely:

```text
mn even and GCD[m,n] <= 2.
```

For `m == n`, there is also the coordinate-swap automorphism. The product-preserving case gives only `n == 2`; the coordinate-swapping case

```wl
{i_, j_} :> {Mod[j + 1, n], i}
```

has exactly two equal orbits only for `n == 4`.

This is a mathematical inference from the rook-graph structure and the bicirculant definition, not a sampled `GraphData` property value.

[1]: https://mathworld.wolfram.com/RookGraph.html "Rook Graph -- from Wolfram MathWorld"
[2]: https://mathworld.wolfram.com/CirculantGraph.html "Circulant Graph -- from Wolfram MathWorld"

RookComplement n×n

seq=Table[GraphData[{"RookComplement",{n,n}},"Bicirculant"],{n,20}]

RookComplement m×n

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"RookComplement",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

ChatGPT Pro 5.5 Heavy thinking

Yes: **same bicirculant classification**, though it is not the same graph.

MathWorld defines the `m x n` rook complement graph as the graph complement of the `m x n` rook graph, with vertex count `m n`. ([MathWorld][1]) For any finite simple graph `G`,

```wl
AutomorphismGroup[G] == AutomorphismGroup[GraphComplement[G]]
```

in the relevant sense: a vertex permutation preserves edges iff it preserves nonedges. Therefore any cyclic automorphism with exactly two equal vertex orbits exists for `G` iff it exists for its complement. This uses the usual bicirculant convention: an automorphism with two vertex-orbits of the same size. ([arXiv][2])

So the same predicate applies:

```wl
rookComplementBicirculantQ[m_Integer?Positive, n_Integer?Positive] :=
  Which[
    m == n, m == 2 || m == 4,
    True, Mod[m n, 2] == 0 && GCD[m, n] <= 2
  ]
```

Equivalently, `GraphData[{"RookComplement", {m, n}}]` is bicirculant exactly when `GraphData[{"Rook", {m, n}}]` is bicirculant.

[1]: https://mathworld.wolfram.com/RookComplementGraph.html?utm_source=chatgpt.com "Rook Complement Graph -- from Wolfram MathWorld"
[2]: https://arxiv.org/abs/2604.21607?utm_source=chatgpt.com "On the hamiltonicity problem of bicirculants: a reduction to cyclic Haar graphs"

SierpinskiCarpet

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

SierpinskiGasket

seq=Table[GraphData[{"SierpinskiGasket",n},"Bicirculant"],{n,7}]

SierpinskiTetrahedron

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

Spoke n×n

seq=Table[GraphData[{"Spoke",{n,n}},"Bicirculant"],{n,5}]

StackedBook n×n

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

StackedBook m×n

DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"StackedBook",{m,n}},"Bicirculant"],
XXX
},{n,10},{m,n}],1],{_,x_,x_}]

StackedPrism n×n

seq=Table[GraphData[{"StackedPrism",{n,n}},"Bicirculant"],{n,3,5}]

StackedPrism m×n

DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"StackedPrism",{m,n}},"Bicirculant"],
XXX
},{m,3,8},{n,5}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Star

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

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

Sun

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

Sunlet

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

Tetrahedral

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

TorusGrid n×n

seq=Table[GraphData[{"TorusGrid",{n,n}},"Bicirculant"],{n,3,20}]

TorusGrid m×n

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"TorusGrid",{m,n}},"Bicirculant"],
XXX
},{n,3,20},{m,3,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Transposition

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

seq=Table[GraphData[{"Transposition",n},"Bicirculant"],{n,6}]

Trapezohedron

Entity["Graph",{"Trapezohedron",n}]["Bicirculant"]

seq=Table[GraphData[{"Trapezohedron",n},"Bicirculant"],{n,3,20}]

Triangular

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

TriangularGrid

seq=Table[GraphData[{"TriangularGrid",n},"Bicirculant"],{n,0,20}]

TriangularHoneycombAcuteKnight

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

TriangularHoneycombBishop

seq=Table[GraphData[{"TriangularHoneycombBishop",n},"Bicirculant"],{n,20}]

TriangularHoneycombObtuseKnight

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

TriangularHoneycombQueen

seq=Table[GraphData[{"TriangularHoneycombQueen",n},"Bicirculant"],{n,20}]

TriangularHoneycombRook

seq=Table[GraphData[{"TriangularHoneycombRook",n},"Bicirculant"],{n,20}]

ChatGPT Pro 5.5 Heavy thinking

Plan: use the MathWorld structure of the graph, then apply the two-equal-orbit definition of bicirculant.

**Answer: no, not for any positive `n`.**

MathWorld gives the `n`-triangular honeycomb rook graph as

```wl
K_1 ⋃ K_2 ⋃ ... ⋃ K_n
```

and says it is implemented as:

```wl
GraphData[{"TriangularHoneycombRook", n}]
```

([MathWorld][1])

Using the MathWorld bicirculant convention from the circulant graph page, a bicirculant has a cyclic symmetry with **exactly two equal group orbits**. ([MathWorld][2])

For `GraphData[{"TriangularHoneycombRook", n}]`, the connected components are complete graphs of distinct orders `1, 2, ..., n`. Therefore every automorphism must preserve each component setwise. Hence every orbit of any cyclic automorphism is contained in a single `K_k`.

So:

* For `n >= 3`, there are at least three connected components, hence at least three vertex-orbit blocks to account for. It cannot have exactly two orbits.
* For `n == 2`, the graph is `K_1 union K_2`, with 3 vertices, so two equal orbits are impossible.
* For `n == 1`, the graph is `K_1`, so again it cannot have two equal nonempty orbits.

So the closed-form answer is:

```wl
triangularHoneycombRookBicirculantQ[n_Integer?Positive] := False
```

This is a mathematical inference from the MathWorld decomposition, not a built-in `GraphData` value.

[1]: https://mathworld.wolfram.com/TriangularHoneycombRookGraph.html "Triangular Honeycomb Rook Graph -- from Wolfram MathWorld"
[2]: https://mathworld.wolfram.com/CirculantGraph.html "Circulant Graph -- from Wolfram MathWorld"

TriangularSnake

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

TruncatedSquareLattice n×n

seq=Table[GraphData[{"TruncatedSquareLattice",{n,n}},"Bicirculant"],{n,10}]

TruncatedSquareLattice m×n

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"TruncatedSquareLattice",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

Web

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

Wheel

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

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

WheelComplement

seq=Table[GraphData[{"WheelComplement",n},"Bicirculant"],{n,4,20}]

WhiteBishop n×n

seq=Table[GraphData[{"WhiteBishop",{n,n}},"Bicirculant"],{n,2,20}]

WhiteBishop m×n

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"WhiteBishop",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet

WhiteCamel n×n

seq=Table[GraphData[{"Bishop",{n,n}},"Bicirculant"],{n,{5}}]

Zebra n×n

seq=Table[GraphData[{"Zebra",{n,n}},"Bicirculant"],{n,20}]

Zebra m×n

Sort@DeleteCases[Flatten[Table[{
{m,n},
GraphData[{"Zebra",{m,n}},"Bicirculant"],
XXX
},{n,20},{m,n}],1],
{_,x_,x_}|{_,_GraphData,_}]//Quiet