show/hide this revision's text 5 Completed code to perform full search (and initial approximation of results)

EDIT: Preliminary results 1

In case there are people who are interested.Finally found some time to do some coding.Implemented branching cutting via symmetry.

PathLength-UniquePaths-NonUniquePaths:

The third column can be viewed as a simple backtracking algorithm but with first 4 vertices fixed. (Therefore symbolizing full path search)
This result seems to show that 2

I should expect the simple symmetry had written better pruning codes and I realized that it takes only at most a couple of paths method weeks to be about 4 times improvement over backtracking (consistently 4 times smaller)finish the running.Simply putHowever, it is not much based on extrapolation of an improvement.
The unoptimized run time for path length 19 is about 400 seconds, which seems to multiply by about 2.5 per increment, where the number of unique paths also multiply by around that amount. This factor initial few branches I had completed, I will slowly decrease as the path length increase.
Around fixing need some whooping 5+ TB of 30 or so vertices, it becomes instantaneous hard disk space just to check store the remaining pathsresults.By some naive estimate Comparing with just measly 24 Hamiltonian cycles for $n=5$, it seems pretty clear that even if I can now try to brute force this in a few months..find all cycles for $n=9$ there is no way I can store all of them. Sad =(
show/hide this revision's text 4 Some preliminary results

EDIT: Preliminary results 1

In case there are people who are interested.Finally found some time to do some coding.Implemented branching cutting via symmetry.

PathLength-UniquePaths-NonUniquePaths:

The third column can be viewed as a simple backtracking algorithm but with first 4 vertices fixed. (Therefore symbolizing full path search)
This result seems to show that I should expect the simple symmetry of paths method to be about 4 times improvement over backtracking (consistently 4 times smaller). Simply put, it is not much of an improvement.
The unoptimized run time for path length 19 is about 400 seconds, which seems to multiply by about 2.5 per increment, where the number of unique paths also multiply by around that amount. This factor will slowly decrease as the path length increase.
Around fixing of 30 or so vertices, it becomes instantaneous to check the remaining paths.
By some naive estimate it seems that I can now try to brute force this in a few months...
show/hide this revision's text 3 added 2 characters in body; added 63 characters in body

Hi everyone!

This is my first post, apologies if I made any mistakes anywhere.

Here goes the question: Consider all length 7 binary sequences. Let $X$ be the set of sequences with hamming weight 3 and let $Y$ be the set of sequences with hamming weight 4. For each vertex in $X$, connect an edge to each element in $Y$ if they differ by only 1 bit. For example, 4 edges will be connected from $0000111$ to $1000111, 0100111, 0010111$ and $0001111$.

This will result in a Bipartite Vertex Transitive graph. To be precise, the resulting graph will be 4 regular.

How can I enumerate all Hamiltonian Cycles in this graph?

Now I am aware that a straight forward bruteforce of the 70 vertices will take forever and the generic dynamic programming approach of TSP is still quite unreachable due to the complexity being in the range of $O(2^{70})$.

The closest reference I come across is Finding and Enumerating Hamilton Cycles in 4-Regular Graphs, where the complexity is $O(1.783^{70})$, but still nowhere close to being solvable. I am now wondering if the additional conditions of the graph being vertex-transitive and bipartite might help be bring down the complexity. Also, there is quite a bit of "special knowledge" about the graph that we can deduce. For example, there cannot be a cycle of length 4.

Please note that this is related to Middle Layers Conjecture. I am interested to know all the Hamiltonian cycles for $k=4$ and $k=5$ (9 and 11 bit binary sequences).

I played around with the idea of using permutations to classify several paths into 1 so that only one representative needs to be checked: Let starting vertex be $0000111$ and suppose I found all Hamiltonian cycles of the form: $R-0001111-0000111-0010111-S$. It appears to me that I can extend this result by applying, say a permutation of bit 1 and 4 to all elements in the cycle to get a new class: $R-1000111-0000111-0010111-S$. Since this is a bijective function between the 2 classes, I would have effective effectively found all cycles in the new class too. I can use this technique to reduce 6 types of cycles of the forms:

$-0001111-0000111-0010111-$

$-0001111-0000111-0100111-$

$-0001111-0000111-1000111-$

$-0010111-0000111-0100111-$

$-0010111-0000111-1000111-$

$-0100111-0000111-1000111-$

into just one case. However, I cannot find a way to generalize this approach too far down to compress more paths. I am interested to know how everyone thinks of this question. Does it seem to be solvable in practical time?

Finally, my pleasure to meet all of you!
show/hide this revision's text 2 added 2 characters in body
show/hide this revision's text 1