I was wondering if A computer solves FMC by using long EOs and short DRs and gets sub 20 all the time while we use short EOs which unnawaringly leads to long DRs and rarely get sub 20's. Is this something we can reserach and improve on to be the gods number?
First, I think it's important to understand how a computer solves the cube. You can think of the cube states as points that are all connected by paths, forming a maze. For any given scramble, you're dropped at a random point on the maze, and you have to find your way to the exit. There's the old strategy for finding the exit of a maze which involves putting your left hand on the wall and always turning left. As long as the maze doesn't have circular paths, this will always work. Unfortunately for us, the cube does have circular paths, so we have to have a way to mark everywhere we've been so that we can avoid them. The resulting algorithm is called a "depth-first search" because it explores the maze by going down one branch as deep as you can, then backtracking up to the next branch.
We can be a little smarter with the cube because we can use heuristics to avoid going to far. For example, we can say we're already 20 moves deep and haven't found the exit, so there's no point in going any further down this particular path.
One challenge is the 43 quintillion states will just take far too long to explore. So what computers do is they split these into two phases, the first being a domino reduction phase, and then the rest. It's important to recognize that these sets are not small - they consist of about 2 billion and 20 billion states respectively.
But we haven't really covered how many paths we have to explore yet. Let's consider the first phase - we have a scrambled cube and we want to get to a DR state. We have 6 faces and can do 3 types of moves on each face (clockwise, counterclockwise, and double turns). So that's 18 choices of move for the first face. For the second face, we don't want to turn the same face twice, so we have 3 fewer choices, and we also don't need to check for example L R if we're already checking R L, because they do the same thing. So we can reduce it down to an average of 13.5 turns we need to check for each move after the first. That means the first step we check 18 states, the second step we check 243 states, and for the third move we have to check 3,240 states. It explodes really quickly. By the time we're looking at 12 moves, there are trillions move sequences to check (the vast majority of which lead to duplicate states).
But we don't have to check all of these sequences. A computer can store a pruning table, so it can know for any state how far it is from domino reduction state. using some smart symmetry tricks and smart bitpacking, a computer can store the number of moves any state is from the DR in tens of megabytes. These are calculated and stored in advance. So the computer can look at any of the 2 billion cases and say that particular case is X moves away from the DR state. That's powerful because it means we can prune (cut away unwanted branches) of the search tree.
It's also worth considering that the computer can iterate through millions of states per second, finding thousands of sequences that lead to DR states.
Then comes the additional magic of pruning tables. It can look up the resulting state in the phase 2 pruning table, and know exactly how many moves away from being solved it is. After DR, the majority of states are still 13 or 14 moves away from being solved. But the computer can throw away those states immediately. The chances of a finish after DR being 6 moves or less are about 1 in 15,000. So if the computer wants to solve the cube in 20 moves, it can find tens of thousands of 14 move DRs and have a good chance of finding one with a 6 move finish. For the computer, checking solutions is as simple as doing a single memory lookup.
Now, a human can't possibly check through tens of thousands of 14 move DR in the hour, so they need to be smarter. They need to be much smarter. It takes at most 12 moves to get to DR, but the majority of scrambles can reach DR in 10 moves. Human's won't blindly explore every move sequence. They'll carefully construct them by solving sub-goals, maybe EO first, then RZP, then look for patterns. They'll throw away any solutions that take too many moves to RZP, and they'll throw away patterns that look hard. So using this technique, they can maybe find 10-15 or so DR solutions that are within a move or two of optimal. We use heuristics like the number of qt to HTR to be able to throw away some solutions that are likely to have long HTR solutions, but we can't look at a DR state and know immediately with certainty whether it is good or not.
And if we look at the distribution the number of moves needed to solve from DR, while most need 13-14, or up to 18 moves to solve, about 1 in 10 can be solved in 11 moves or less, and about 1 in 40 can be solved in 10 moves or less. So out of the 10-15 DR states averaging about 10 moves that a top performing human could reasonably find in an attempt, that may be as short as 10 moves on average, they should be able to find a 10 or 11 move finish if they could be perfectly optimal.
That's why the limit for human FMC in an hour is probably a global average of about 21 moves. We'll see some better means if there are lucky scrambles, but overall, we'll probably never see a human with a global average sub God's number.
So what would it take for a human to us a method closer to a computer? We'd need to be able to come up with tens of thousands of 14 move DRs. This is actually easier than it seems, and the only real challenge here is time. We just aren't fast enough to do it in an hour. But if someone could devote a week of their life to listing all fo the 14 move DRs they can find? It's not goign to be fun, but it becomes marginally more feasible. The next thing they need is to be able to look at every DR state and know accurately whether or not it can be solved in 6 moves or less. This is the hard part. We'd need to allow the person to have an absurdely long alg sheet (even with symmetry, it would need to list about a billion cases), and they'd need an extremely efficient way to find a specific case on that sheet.
This is the barrier that you need to find a way to overcome. I'm not convinced that it's possible.
