Man's number challenge

CubingKid

Regular
Joined
Jan 19, 2025
Messages
37
Location
Portugal
Hello guys. I have been for a while playing arround with a challenge that I have called the "Man's number" challenge (by Man, here I mean the "human beeing" meaning of the word, women are also very welcome to the challenge!! :)). The porpous of the challenge is following: try to determine the value of God's number without the assistence of computers.

Here are the rules: the usage of computer programs to do something a real human would not realistically be able to do (like finding solutions for millions of states of the rubik's cube in 20 moves or less) is completely banned. Using a computer to generate solutions for individual cube states or specific states on a substep is allowed, but it can't be considered "provenly optimal" for the porpouses of the challenge, in order to avoid computer based lower bound proving. Programs that do not give any kind of unfair advantage are allowed, like for example but not likited to notepad, paint and calculator (as calculations could technically instead be done on paper, doing them on a computer simply makes them more efficient as reduces errors).

Since proving that the God's number is 20 without using a computer is on practice, impossible, instead I'll be focusing on increasing the lower bound and decreasing the upper bound. For the lower bound I'll be looking at both the constructive lower bound (where you find a specific state of the cube and prove it requires at least n moves to solve) and the non-cobstructive lower bound (where you prove a state that requires at least n moves to solve must exist).

- The non-constructive lower bound
Using a clever counting trick, a lower bound for the God's number can be set as 17. The idea is simple, there are ~4.325*10^19 possible states that a rubik's cube may be at. However, only 1 state can be reached after 0 turns, so clearly a state requiring at least 1 move must exist.
Similarly, only 18 valid moves exist, which means at most 18 states may be reached in exactly 1 move, or 1+18=19 total states if you also count the 0 move state, but since 19 is still strictly less than 4.325^10^19, there must be a position that requires at least 2 moves to solve. I promise I won't list you all the values up to 17, but it is really important I still talk about the 2 move states. For 2 move states, you may think we have 18² of them, since you could do any one of 18 moves for the first one, and any one of them for the secound one, however, we can do better than that. Since 3 of the options for the secound move would just turn the same side again, we don't actually have to consider them, reducing the ammount of options for the secound move (and for all subsequent others for that matter) to 15. Thus, we have exactly 18*15=270 possible 2-move-long move combinations. That results in a running total of 289 move combinations up to 2 moves long, which is clearly less than 4.325*10^19, so a state requiring at least 3 moves must exist. If you keep applying this logic, you'll reach the conclusion that, in htm, a state of the rubik's cube requiring at least 17 moves to solve must exist. The reason why this is a lower-bound and not a definitive proof for the God's number is because multiple move sequences may generate the same state. A comic example of such is the sequence of 9 moves "R2 F2 B2 L2 D2 R2 F2 B2 L2", which does the exact same thing as the sequence of 1 move "U2".

- Constructive lower bound
Now, with the added restriction of actually finding a specific case and proving it actually must require at least n moves to solve, it becomes much harder, since the super efficient counting trick doesn't work anymore. When JPerm tried this on his video about the God's number, he constructively proved that a cube hand-scrambled by him required at least 2 moves to solve by going thru every single one of the possible 1 move combinations and showing that none of them solved the cube, and thus the cube required at least 2 moves to solve and thus the God's number is at least 2. As good as this was as an example to help his viewers understand what a constructive lower bound is, it is a really bad bound, as I was capable of creating an algorithm (computer science definition of algorithm, not cubing definition of algorithm) for determining the lower bound for any given state of the cube, and the maximum lower bound it can generate happends to be 9 on some very specific scrambles, and so that is my constructive lower bound. The way how this algorithm works is the following: firstly, count how many edges are bad edges (unoriented). If this ammount is 4, then at least one F or B move is required to orient them, and they must be oriented for the cube to be solved. If there are 2, 6, or 8 bad edges, then at least 2 F or B moves are required to orient them. If 10 or 12 edges are bad edges, then at least 3 F or B moves. Now repeat this proccess for the LR and UD axies and add the ammount of required F/B moves to the ammount of L/R moves and to the ammount of U/D moves. On the worst case this would be 3 F/B moves + 3 L/R moves + 3 U/D moves = 9 moves. So this proves that ANY state that has at least 10 bad edges in each axis must require at least 9 moves to solve. A famous example of this is the superflip (the state where all corners are solved and all edges are flipped in their place), which was also the state used to prove the lower bound of 20 in the version of this challenge that allows for computers.

- Upper bound
This one is, by a long shot, the hardest of the 3 bound to set, since it requires proving that ALL rubik's cube states can be solved in at most m moves, rather than proving that a state requires at least n moves. The most streight forward way to do this is by creating a solving method and strictly proving, without the usage of computers, that each substep must require at most n moves, and then summing the maximum ammount of moves for each state.

First, I'll walk thru a trivial solution for this using the old pochmann method, and then I'll walk thru a proper method I developed for this challenge specifically.

Since the old pochmann example will just be a trivial demonstration, I won't bother about efficiency too much. I'll also be using the standard T perm, R perm, modified-Y perm variation. For corners, the maximum ammount of targets you can have is 14, which would happend if all corners are twisted. The longest setup move for corners is 2 moves, and the swapping algorithm itself is 15 moves. This totals a maximum of (2+15+2)*14=266 moves for corners. Similarly, the worst case for edges would have 22 targets, when all edges are flipped. The longest setup move for edges is 4 moves long, and the swapping algorithm itself is 14 moves long, resulting in a maximum of (4+14+4)*22=396 moves for edges. The parity algorithm is 16 moves, so the upper bound for this version of old pochmann is 266+396+16=678 moves. This upper bound os absolutely horrendous and tremendously unoptimised, but it wasn't meant to be otherwise anyway.

Now for the actual method I developed, which is a variation of Petrus. Since I wanted to actually rigurously prove each step's upper bound (it is a requirement of the challenge; the challenge (the upper bound part of it) is to prove that the cube MUST be solveable in at most n moves, not that it probabilly will always be), I chose to opt for a mostly piece-by-piece aproach, specially on the first few steps, where solving 2 pieces at a time will easilly reach the hundreds of algorithms/cases. The following is a list of the steps of the method, along with the alg count/case count for each step, the maximum ammount of moves it can require to be solved and the running total.
It will be formatted as such:
[Step name] - [move count] - [running total] - [case count; including skip case, such that multiplying all theese numbers should result in the ammount of states of the cube] // [Aditional comments]
DB - 3 - 3 - 24
DBL - 3 - 6 - 24
DL - 5 - 11 - 22
BL - 5 - 16 - 20
DF - 4 - 20 - 18
DFL - 6 - 26 - 21
FL - 6 - 32 - 16
EO - 8 - 40 - 64 // by abusing simetries, it is possible to do an alg list with less than 63 algs. I was capable of doing it in 30-few
DR (down-right edge piece, NOT domino reduction) - 2 - 42 - 7
DBR - 7 - 49 - 18
BR - 5 - 54 - 6 // Note: on the future I plan on making DBR and BR a single step called 3rd F2L pair.
F2L - 10 - 64 - 75 // Thanks to António Gomes for providing me some efficient algorithms for this step, without him I would still be stuck on 12 moves.
OCLL - 10 - 74 - 27 // When done in isolation, this step may require up to 11 moves. However, since only the worst case matters, we must assume we did not skip the last F2L slot. All last F2L slot cases end with a R* move, and all 11-move OCLL cases may be done starting on a R*, which means that this step will always cancel at least 1 move with the previous one.
PLL - 15 - 89 - 288 // AUF included in this step. That's why the worst case is 15 rather than 14. I did this to simplify "alg count" calculations.

In case you didn't understand fully the notation, or completely skipped the method definition (which I would not recommend at all), all that is there to say that the upper bound is 89 moves. Altho this upper bound is much better than the previous 678 one, it still is not enough to always fit in the FMC limit of 80 moves, which is annoying.


And I finish it here, wishing to read what you all think about this challenge and to see what brilliant original solutions you come up with. Also remember, please do not cheat. The actual answer has been known for douzens years to be 20, so cheating is really just a way to steal everyone's fun. I also think that there is little to no progress to be made in the lower bound section of this (maybe on the constructive lower bound side??), so I would recommend you to try to improve the upper bound instead.
 
Here are some pictures of my notebook where I worked on this challenge.
 

Attachments

  • 17746539223512212868451030088192.jpg
    17746539223512212868451030088192.jpg
    143.6 KB · Views: 18
  • 1774653959141798052120229127084.jpg
    1774653959141798052120229127084.jpg
    142.7 KB · Views: 19
  • 17746540568255552000792001773669.jpg
    17746540568255552000792001773669.jpg
    136.3 KB · Views: 16
  • 17746540729976222319670216189428.jpg
    17746540729976222319670216189428.jpg
    155.9 KB · Views: 15
Update: Because of a suggestion by Xingu Zhu (朱星宇) (2023ZHUX01) I decided to take a look into cfop for this challenge. Altho for fmc cfop is usually less efficient than Petrus, because of how repetitive the cfop f2l is, it becomes easier to optimise one thing and for it to help you in the rest of the f2l pairs. You also get the benefit of not having to preserve EO, at the cost of not having the benefit of EO either.

The idea first appeared when he proposed a trivial way to solve any f2l pair in at most 11 moves in a 2 step process: first take out the corner piece in 3 moves while making sure the white sticker in not pointer upwards, then do 1 move as pre-auf, then setup the pair in 3 moves, then do pre-auf again and finally insert the pair in 3 moves. 3+1+3+1+3=11.

This itself is a great step forward, since now we can do f2l quite efficiently, however, it can't be called a method of you can't prove an upper bound for the cross. I was quick to remember some tests I had done in the past when playing arround with this challenge. The best I have managed to prove as an upper bound for the cross is 13 moves. First, put any of the cross pieces in the D layer (with the white sticker pointing downwards) in at most 2 moves. Now, put the cross piece that belongs to the right of this one to the right of this one in at most 3 moves. Repeat the secound step for the 3rd piece. For the forth piece, do the same thing, this time in at most 4 moves. Finally, correct the cross so that the pieces are in the place they actually belong to (ADF; adjust D face) in 1 move. 2+3+3+4+1=13.

Then, I proved that all last slot cases can be solved in at most 9 moves by listing all of them and providing a solution in at most 9 moves (in the cases where at least 1 of the pieces is outside of the slot, a solution up to 8 moves was provided and pre-auf was assumed) in a youtube video:
Note: the youtube video is in portuguese, not in english.

For last layer I simply got the length of the longest OLL and PLL from the speedsolving wiki. Since I did not prove that those algs are optimal, for the porpouses of this challenge I can't state that they are, but since on practice I know they are, no efforts into optimising those algs will ever be put from my side. Longest OLL: 12 moves; longest PLL: 14 moves; longest AUF: 1 move. This totals for 27 moves in last layer.

Now the important question: does this beat my previous 89 move solution? Well, 13 + 11x3 + 9 + 27 = 82, so it does beat my previous solution by 7 whole moves, ironicaly making the "so close to proving fmc is possible" even more annoying. Probabilly next I'll try to improve on this by introducing some 1 look last layer algorithms. Only 1 and exactly 1 oll case actually requires 12 moves to be solved, ALL others are 11 moves long. This OLL also happends to be the rarest case of them all, which just adds to the irony. This case is the checkerboard case, also known as OLL case 20 or the dot case with all corners oriented correctly. Because of the ammount of simetries of this oll case beeing the exact ammount of simetries that pll has, it would'nt be too hard to provide a 1lll alg for every case that would otherwise result in getting a 14 move pll after doing this oll. Even lazierly, a full anti-pll list could be provided so that we don't have to warry at all, we know that none of those algs would pass 20 moves since the God's number is 20, altho an actual list would need to be provided for it to be "proven" in the context of this challenge. Anyway, don't be afraid to suggest any ideas you may have for this challenge, I'm very open to trying out the ideas you guys may have :)
 
I assume you really mean "human-verifiable" rather than truly computer-unassisted, since that would rule out computer-generated algs (which you seem to allow).

ZBLL mod AUF is known to be 15 moves worst case, with the two 15-movers being pure H and this diag-T L4C case:
 Twizzle link 
 Setup 
R' U2 R U2 R2 B' D' R' F R2 F' D B U' R' U'
 Moves 

 Twizzle link 
 Setup 
R U' F' D2 F2 D' F' U' F D F2 D2 F U2 R'
 Moves 


Pure H can be verified to be 16 moves if the pieces are all permuted correctly, 15 moves for the other AUFs; the bad diag-T L4C is 15 moves for every AUF. (Verifying by hand that Helmstetter's list is complete and accurate is tedious but can be done, considering that it's only 270 cases.)

EO is 6 moves for the 2-flip cases, 11 moves for 4-flip (e.g. R U' R2 D' r U r' D R2 U R'). By mirroring/rotating this 4-flip alg, any F2L solution that ends in a quarter turn can cancel at least two moves. By switching to R U' R2 D' r U' r' D R2 U R', which also fixes 4-flip but permutes the edges differently, we can avoid the 16-move ZBLL finish.

If the F2L ends in a half turn, then R2 F2 L F2 R F' L2 U2 L F R similarly allows cancelling at least two moves, with an alternate alg R2 r' U R' U r U2 r' U M' to avoid 16-move ZBLL finish.

This gives last layer in 9 + 15 = 24 moves at most, assuming not F2L skip.
 
Last edited:
I assume you really mean "human-verifiable" rather than truly computer-unassisted, since that would rule out computer-generated algs (which you seem to allow).

ZBLL mod AUF is known to be 15 moves worst case, with the two 15-movers being pure H and this diag-T L4C case:
 Twizzle link 
 Setup 
R' U2 R U2 R2 B' D' R' F R2 F' D B U' R' U'
 Moves 

 Twizzle link 
 Setup 
R U' F' D2 F2 D' F' U' F D F2 D2 F U2 R'
 Moves 


Pure H can be verified to be 16 moves if the pieces are all permuted correctly, 15 moves for the other AUFs; the bad diag-T L4C is 15 moves for every AUF. (Verifying by hand that Helmstetter's list is complete and accurate is tedious but can be done, considering that it's only 270 cases.)

EO is 6 moves for the 2-flip cases, 11 moves for 4-flip (e.g. R U' R2 D' r U r' D R2 U R'). By mirroring/rotating this 4-flip alg, any F2L solution that ends in a quarter turn can cancel at least two moves. By switching to R U' R2 D' r U' r' D R2 U R', which also fixes 4-flip but permutes the edges differently, we can avoid the 16-move ZBLL finish.

If the F2L ends in a half turn, then R2 F2 L F2 R F' L2 U2 L F R similarly allows cancelling at least two moves, with an alternate alg R2 r' U R' U r U2 r' U M' to avoid 16-move ZBLL finish.

This gives last layer in 9 + 15 = 24 moves at most, assuming not F2L skip.
Yeah, I do allow things that I consider that a human would be capable to do to be done by a computer. Since world class FMCers would likely eventually find the optimal solution for any cube state, I allow for computer generated solutions, however, they are not considered to be optimal since you can't strictly prove them to be. In a way, your definition of "human verifyable" ends up beeing more fitting in a way, yeah. Additionally, I chose to stay away from ZBLL because I don't fully know it myself, altho it's not banned at all from this challenge, even if you don't know zbll, since I'm considering ZBLL to be humanly possible to be learnt.

As a side note, you are allowed to assume no F2L skip, since we only care about the overall method worst case, and solving F2L in the worst case takes way over the 2 moves that skipping it costs.

Also, since EO currently takes 9 moves in the worst case, I encourage you to experiment with VHLS (or ZBLS if you are brave enough) to see how much it is possible to lower the move count ;)
 
Last edited:
Sure, ZBLS gives easy improvements.

The prior bound for LSLL is 9 (last slot) + 24 (last layer including cancellation with last slot) = 33 moves.

The only LS cases that cannot be done in 8 moves are flipped edge only and twisted corner only.

ZBLS for flipped edge is 11 moves at most (9 moves for 1-flip, 10 moves + AUF for 3-flip), giving an upper bound of 11 (ZBLS) + 16 (ZBLL) = 27 moves.
ZBLS for twisted corner is 11 moves at most (9 moves for 0-flip, 9 moves + AUF for adj-flip, 10 moves + AUF for opp-flip, 11 moves for 4-flip), giving an upper bound of 11 (ZBLS) + 16 (ZBLL) = 27 moves as well.

For the other cases, normal LS gives an upper bound of 8 + 24 = 32 moves. So we now have an overall upper bound of 32 moves for LSLL.

You could repeat this for the 8-move LS cases but that starts to get really annoying…
 
I have noticed that in the video I made and linked in a previous reply in this post some of the f2l solutions I showed were suboptimal. I will soon make a new version of the video and edit the original reply to instead link to the updated version. This will not change the worst case move count.
 
Back
Top