Comment by PaulHoule

That's what, 255 moves? A reasonable way to do that via CoT would be for it to determine the algorithm for solving it (which it might "know" because it was in the training data, or perhaps it can look up with a search engine, or perhaps it can derive it) and then work all the steps.

If it has a 1% chance of making a mistake per step, which is likely, because the vector space data structure isn't the right structure to represent the problem, from the viewpoint of ordinary software, it has about an 8% chance of getting the whole thing right. I don't like those odds.

On the other hand, most LLMs can write a decent Python program to solve Hanoi, such as

    def tower_of_hanoi(n, source, target, auxiliary):
        if n == 1:
            print(f"Move disk 1 from {source} to {target}")
            return
        tower_of_hanoi(n - 1, source, auxiliary, target)
        print(f"Move disk {n} from {source} to {target}")
        tower_of_hanoi(n - 1, auxiliary, target, source)

(thanks Copilot!) and if you (or it) can feed that to a Python interpreter there is your answer, unless N is so big it blows out the stack. (One of my unpopular opinion is that recursive algorithms are a lower teaching)

I wouldn't expect most humans to get Hanoi right at N=8 unless they were super-careful and multiple-checked their work. Something I learned getting a PhD in theoretical physics is that even the best minds won't get a 50-page calculation right unless they back it up with unit and integration tests.