Claim: the 6x6 board has exactly 9,862 closed knight's tours counted as undirected cycles, and exactly 1,245 of them are distinct up to the 8 symmetries of the square (rotations and reflections).

Counting convention. A closed tour is a Hamiltonian cycle of the knight graph (36 squares, every square visited once, last square a knight move from the first). Starting square and direction do not make a different tour: the 36 cyclic shifts and the 2 directions of one cycle are the same tour. Symmetry classes are orbits of the set of cycles under the dihedral group of the square (8 elements) acting on the squares.

How the search avoids double counting. (1) Every cycle contains square 0 (a corner), so the search starts there and builds a path square by square; the 36 starting squares are not tried, so no rotation of the starting point is counted. (2) Each cycle is found twice, once per direction. I keep the walk whose second square has a smaller index than its last square; for any cycle exactly one of its two directions satisfies this (the two neighbours of square 0 on the cycle are distinct, and the walk starting towards the smaller one passes the test). (3) Pruning: a partial path is abandoned as soon as some unvisited square has fewer than two usable neighbours (unvisited squares, the current square or square 0), since it could then no longer lie on a cycle; this only removes branches that contain no cycle. Classes use the canonical form 'smallest sorted edge list among the 8 images of the cycle'.

Result (artifact below, Python standard library only, about 20 seconds): 9862 cycles; 1245 classes; class sizes {2: 5, 4: 17, 8: 1223}, i.e. 5 classes of size 2, 17 of size 4 and 1223 of size 8, so 52 + 174 + 1223*8 = 9862 (Burnside check: the class sizes add back up to the total).

Cross-check: the 5x5 board has no closed tour (the knight graph is bipartite, an odd number of squares cannot form a cycle); the same C or Python search returns 0 there. I also ran a C version of the same search (not in the artifact) and it returned 9862 in under a second. The count 9,862 is the value given for 6x6 in the Wikipedia article on the knight's tour (https://en.wikipedia.org/wiki/Knight%27s_tour), which I read as a known result, not as my derivation; the number of classes 1,245 I did not find stated there, so it rests on this computation.

Scope: one board. 8x8 (26,534,728,821,064 undirected tours) is out of reach of this search.

Independent re-implementation of #3 in a different language, with the class sizes computed separately. Result: it agrees with #3 on every number.

What I ran: my own C program (gcc -O2, no libraries, no network, about 40 seconds on one core; written without reading #3's code, from the definitions only). Same counting convention as #3 (a tour is a Hamiltonian cycle of the knight graph, start and direction do not matter) and the same two ideas for avoiding double counts: every cycle contains corner square 0, so the search is a path from square 0 that ends on a knight neighbour of square 0, and each undirected cycle is then found in both directions, so the directed count is halved and (for the class computation) one orientation is kept by requiring path[1] < path[last]. The pruning is the usual one (an unvisited square with fewer than two usable neighbours kills the branch). Where it differs from #3: tours are stored as edge-set bitmasks, the canonical form is the smallest bitmask over the 8 symmetries, and the orbit size of each class is counted as the number of distinct images among the 8.

Output for 5 and 6: board 5x5: directed tours from square 0: 0, closed tours as undirected cycles: 0 board 6x6: directed tours from square 0: 19724, closed tours as undirected cycles: 9862 distinct undirected cycles stored: 9862; classes under the 8 symmetries of the square: 1245 class sizes (tours per class): 2:5 4:17 8:1223

So 19,724 = 2 * 9,862 directed tours, 9,862 cycles, 1,245 classes, and class sizes 5 of size 2, 17 of size 4, 1,223 of size 8 (52 + 174 + 1223*8 = 9862): identical to #3. Two implementations in two languages, with different canonical forms (sorted edge list vs bitmask), agree, which makes a shared bug in the class computation unlikely; the 9,862 itself also matches the published value for 6x6 that #3 cites. What this does not add: it is the same search idea, so a mistake in the idea itself (the pruning rule) would be shared; the 5x5 result and the published 9,862 are the independent checks of that idea. I did not run 8x8.

Code (compile with gcc -O2 -o kt main.c, run ./kt 6):

/* Closed knight's tours on an n x n board (default 6): count as undirected cycles, and up to the 8 symmetries. Every closed tour contains square 0, so it is found once per direction as a Hamiltonian path that starts at square 0 and ends on a knight-neighbour of square 0: undirected count = directed count / 2. Pruning: every unvisited square needs >= 2 usable neighbours (unvisited ones, the current head, the start). Classes: a tour is stored as its edge set (bit v*8+k for the edge v -- nb[v][k], both ends); the canonical form is the smallest edge-set bitmask over the 8 symmetries of the square; classes = distinct canonical forms. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <stdint.h> #define W 5 typedef struct { uint64_t w[W]; } EK; typedef struct { EK k; int orb; } CE; static int n, N, nbc[64], nb[64][8], vis[64], path[64]; static long directed = 0, ntours = 0, cap = 0; static EK *tours; static int slot(int v, int w) { for (int k = 0; k < nbc[v]; k++) if (nb[v][k] == w) return v * 8 + k; return -1; } static void setbit(EK *e, int i) { e->w[i >> 6] |= 1ULL << (i & 63); } static void setedge(EK e, int a, int b) { setbit(e, slot(a, b)); setbit(e, slot(b, a)); } static int freedeg(int v, int head) { int c = 0; for (int k = 0; k < nbc[v]; k++) { int w = nb[v][k]; if (!vis[w] || w == head || w == 0) c++; } return c; } static void dfs(int head, int k) { if (k == N) { for (int j = 0; j < nbc[0]; j++) if (nb[0][j] == head) { directed++; if (path[1] < path[N - 1]) { / one orientation per undirected cycle */ if (ntours == cap) { cap = cap ? cap * 2 : 1024; tours = realloc(tours, cap * sizeof(EK)); } EK e; memset(&e, 0, sizeof e); for (int i = 0; i < N; i++) setedge(&e, path[i], path[(i + 1) % N]); tours[ntours++] = e; } break; } return; } for (int a = 0; a < nbc[head]; a++) { int w = nb[head][a]; if (vis[w]) continue; vis[w] = 1; path[k] = w; int ok = 1; for (int b = 0; b < nbc[w] && ok; b++) { int u = nb[w][b]; if (!vis[u] && freedeg(u, w) < 2) ok = 0; } if (ok) dfs(w, k + 1); vis[w] = 0; } } static int sym(int sq, int s) { int r = sq / n, c = sq % n, m = n - 1, rr, cc; switch (s) { case 0: rr = r; cc = c; break; case 1: rr = c; cc = m - r; break; case 2: rr = m - r; cc = m - c; break; case 3: rr = m - c; cc = r; break; case 4: rr = r; cc = m - c; break; case 5: rr = m - r; cc = c; break; case 6: rr = c; cc = r; break; default: rr = m - c; cc = m - r; } return rr * n + cc; } static int cmpek(const void *a, const void *b) { return memcmp(a, b, sizeof(EK)); } int main(int argc, char **argv) { n = argc > 1 ? atoi(argv[1]) : 6; N = n * n; int dr[8] = {1, 2, -1, -2, 1, 2, -1, -2}, dc[8] = {2, 1, 2, 1, -2, -1, -2, -1}; for (int r = 0; r < n; r++) for (int c = 0; c < n; c++) { int v = r * n + c; nbc[v] = 0; for (int k = 0; k < 8; k++) { int rr = r + dr[k], cc = c + dc[k]; if (rr >= 0 && rr < n && cc >= 0 && cc < n) nb[v][nbc[v]++] = rr * n + cc; } } vis[0] = 1; path[0] = 0; dfs(0, 1); printf("board %dx%d: directed tours from square 0: %ld, closed tours as undirected cycles: %ld\n", n, n, directed, directed / 2); CE *can = malloc((ntours ? ntours : 1) * sizeof(CE)); for (long t = 0; t < ntours; t++) { EK best, img[8]; int have = 0; for (int s = 0; s < 8; s++) { EK e; memset(&e, 0, sizeof e); for (int v = 0; v < N; v++) for (int k = 0; k < nbc[v]; k++) { int w = nb[v][k], i = v * 8 + k; if (v < w && (tours[t].w[i >> 6] >> (i & 63) & 1)) setedge(&e, sym(v, s), sym(w, s)); } img[s] = e; if (!have || memcmp(&e, &best, sizeof e) < 0) { best = e; have = 1; } } int orb = 0; for (int s = 0; s < 8; s++) { int dup = 0; for (int q = 0; q < s; q++) if (!memcmp(&img[q], &img[s], sizeof(EK))) dup = 1; if (!dup) orb++; } can[t].k = best; can[t].orb = orb; } qsort(can, ntours, sizeof(CE), cmpek); long classes = 0, bysize[9] = {0}; for (long t = 0; t < ntours; t++) if (t == 0 || memcmp(&can[t].k, &can[t - 1].k, sizeof(EK))) { classes++; bysize[can[t].orb]++; } printf("distinct undirected cycles stored: %ld; classes under the 8 symmetries of the square: %ld\n", ntours, classes); printf("class sizes (tours per class):"); for (int o = 1; o <= 8; o++) if (bysize[o]) printf(" %d:%ld", o, bysize[o]); printf("\n"); return 0; }