• Welcome to the Speedsolving.com, home of the web's largest puzzle community!
    You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

    Registration is fast, simple and absolutely free so please, join our community of 35,000+ people from around the world today!

    If you are already a member, simply login to hide this message and begin participating in the community!

Announcing: New 4x4x4 Brute Force Solver

Status
Not open for further replies.
Joined
Oct 31, 2008
Messages
269
Likes
14
I'll run those cases too.

I've finally got my "untwister" working, and usually there are multiple
solution sequences that it finds; I don't know which might be easiest
for speedsolvers so I'm dumping them all (at least the ones that
preserve overall cube orientation).

Here are the current set of solutions to the sequences you've posted.
I've given each a unique number.

(Note that I'm using the JavaScript alg.cubing.net and not the
Java applet, so I change r to 2R and so on.)

For (seq1002): F2 U' 2L' 2R' U F' L U' F 2L 2R F' U L' F'
Uw2 Fw D2 R' B' L Dw2 U2 R' F L D2 Bw' Dw2
Uw2 Fw D2 R' B' L Uw2 U2 L' B R D2 Fw' Uw2
Uw2 Bw R2 U' B' D Lw2 L2 D' B U R2 Bw' Uw2
Dw2 Bw D2 L' F' R Dw2 U2 L' B R D2 Fw' Uw2
Dw2 Bw D2 L' F' R Uw2 U2 R' F L D2 Bw' Dw2
Dw2 Fw L2 U' F' D Rw2 R2 D' F U L2 Fw' Dw2

For (seq1003): 2R2 U' B2 U' F L F' 2R2 F L' F' U B2 U 2R2
Rw2 U L B' Lw Dw2 Fw2 B2 Dw2 Lw' F L' D' Lw2
Rw2 U L B' Lw Dw2 Bw2 B2 Dw2 Lw' B L' U' Rw2
Rw2 U L B' Lw Uw2 Bw2 F2 Uw2 Lw' F L' D' Lw2
Rw2 U L B' Lw Uw2 Fw2 F2 Uw2 Lw' B L' U' Rw2
Rw2 U L B' Rw Fw2 Uw2 D2 Fw2 Rw' F L' D' Lw2
Rw2 U L B' Rw Fw2 Dw2 D2 Fw2 Rw' B L' U' Rw2
Rw2 U L B' Rw Bw2 Dw2 U2 Bw2 Rw' F L' D' Lw2
Rw2 U L B' Rw Bw2 Uw2 U2 Bw2 Rw' B L' U' Rw2
Lw2 D L F' Lw Uw2 Bw2 F2 Uw2 Lw' B L' U' Rw2
Lw2 D L F' Lw Uw2 Fw2 F2 Uw2 Lw' F L' D' Lw2
Lw2 D L F' Lw Dw2 Fw2 B2 Dw2 Lw' B L' U' Rw2
Lw2 D L F' Lw Dw2 Bw2 B2 Dw2 Lw' F L' D' Lw2
Lw2 D L F' Rw Bw2 Dw2 U2 Bw2 Rw' B L' U' Rw2
Lw2 D L F' Rw Bw2 Uw2 U2 Bw2 Rw' F L' D' Lw2
Lw2 D L F' Rw Fw2 Uw2 D2 Fw2 Rw' B L' U' Rw2
Lw2 D L F' Rw Fw2 Dw2 D2 Fw2 Rw' F L' D' Lw2

For (seq1006): R2 2R' F' L R F 2R' F' R' F 2R2 F' L' F R2
U F B' Dw B U' B' Dw2 U F' U' F Dw F' B
U F B' Uw R U' R' Uw2 U R' U' R Uw F' B

For (seq1007): 2R2 U F2 U B' R B 2R2 B' R' B U' F2 U' 2R2
R U' Fw2 B L2 Fw2 U Fw2 L2 Fw2 U B' U R'
R U' Fw2 B L2 Fw2 U Bw2 R2 Bw2 U B' U R'
R U' Fw2 B L2 Bw2 D Fw2 R2 Bw2 U B' U R'
R U' Fw2 B L2 Bw2 D Bw2 L2 Fw2 U B' U R'
R U' Bw2 B R2 Fw2 D Fw2 R2 Bw2 U B' U R'
R U' Bw2 B R2 Fw2 D Bw2 L2 Fw2 U B' U R'
R U' Bw2 B R2 Bw2 U Fw2 L2 Fw2 U B' U R'
R U' Bw2 B R2 Bw2 U Bw2 R2 Bw2 U B' U R'

For (seq1016): 2L2 2R2 U 2R2 F2 2R2 F2 U' 2L2 2U2 2R2 2U2
F2 B2 D Dw2 B2 R2 Fw2 U2 Uw2 B2 L2 Fw2 D F2 B2
F2 B2 D Dw2 B2 R2 Bw2 D2 Dw2 B2 R2 Bw2 D F2 B2
F2 B2 D Uw2 F2 L2 Bw2 U2 Dw2 B2 L2 Fw2 D F2 B2
F2 B2 D Uw2 F2 L2 Fw2 D2 Uw2 B2 R2 Bw2 D F2 B2

For (seq1017): 2L2 2R2 U' 2R2 F2 2R2 F2 U 2L2 2U2 2R2 2U2
F2 B2 D' Dw2 F2 L2 Fw2 D2 Dw2 F2 L2 Fw2 D' F2 B2
F2 B2 D' Dw2 F2 L2 Bw2 U2 Uw2 F2 R2 Bw2 D' F2 B2
F2 B2 D' Uw2 B2 R2 Bw2 D2 Uw2 F2 L2 Fw2 D' F2 B2
F2 B2 D' Uw2 B2 R2 Fw2 U2 Dw2 F2 R2 Bw2 D' F2 B2

For (seq1018): 2R2 U' 2R2 F2 2R2 F2 U2 F2 2R2 F2 2R2 U' 2R2
R2 Fw2 Rw2 U' R2 F2 R2 U2 R2 F2 R2 U' Rw2 Fw2 R2
R2 Fw2 Lw2 D' R2 B2 R2 D2 R2 B2 R2 D' Lw2 Fw2 R2
R2 Bw2 Lw2 D' L2 F2 L2 D2 L2 F2 L2 D' Lw2 Bw2 R2
R2 Bw2 Rw2 U' L2 B2 L2 U2 L2 B2 L2 U' Rw2 Bw2 R2

For (seq1019): F' R' 2D R U R' 2D' 2U' R U' R' 2U R F
F2 Rw2 U R2 U' R2 L2 D R2 D' R2 Rw2 L2 F2
F2 Lw2 D R2 D' R2 L2 U R2 U' R2 Lw2 L2 F2

For (seq1020): R2 D' F2 2F' U 2F U2 2F' U F2 U' 2F U2 2F' U' 2F D R2
Fw2 R2 F' Fw Rw2 F L F' Rw2 F Fw' R2 Fw L' Fw
Fw2 R2 F' Fw Rw2 F L F' Rw2 F Bw' D2 Fw U' Bw
Fw2 R2 F' Fw Rw2 F L F' Rw2 F Bw' D2 Bw L' Fw
Fw2 R2 F' Fw Lw2 B L B' Lw2 F Fw' R2 Fw L' Fw
Fw2 R2 F' Fw Lw2 B L B' Lw2 F Bw' D2 Fw U' Bw
Fw2 R2 F' Fw Lw2 B L B' Lw2 F Bw' D2 Bw L' Fw
Fw2 R2 F' Bw Uw2 F D F' Uw2 F Bw' R2 Fw L' Fw
Fw2 R2 F' Bw Dw2 B D B' Dw2 F Bw' R2 Fw L' Fw
Bw2 L2 F' Fw Lw2 F R F' Lw2 F Fw' L2 Bw U' Bw
Bw2 L2 F' Fw Rw2 B R B' Rw2 F Fw' L2 Bw U' Bw
Bw2 L2 F' Bw Dw2 F U F' Dw2 F Fw' D2 Fw U' Bw
Bw2 L2 F' Bw Dw2 F U F' Dw2 F Fw' D2 Bw L' Fw
Bw2 L2 F' Bw Dw2 F U F' Dw2 F Bw' L2 Bw U' Bw
Bw2 L2 F' Bw Uw2 B U B' Uw2 F Fw' D2 Fw U' Bw
Bw2 L2 F' Bw Uw2 B U B' Uw2 F Fw' D2 Bw L' Fw
Bw2 L2 F' Bw Uw2 B U B' Uw2 F Bw' L2 Bw U' Bw

For (seq1021): R2 2R2 U2 R2 U' 2R U2 2L 2R U' R2 U 2L' 2R' U2 2R' U' R2 2R2
F2 Rw2 U' F2 U F2 B2 D' F2 D F2 B2 Rw2 F2
F2 Lw2 D' B2 D B2 F2 U' B2 U B2 F2 Lw2 F2

For (seq1026): 2L2 2R2 U' 2L' 2R U2 F2 2L 2R F2 D2 F2 2L2 F2 2L2 D2 2R2 U' 2L2 2R2
Fw2 U2 Rw2 D B2 L2 Fw2 U2 B2 Bw2 U' Fw2 D2 B2 Rw2
Fw2 U2 Rw2 D B2 L2 Fw2 U2 B2 Fw2 D' Bw2 D2 B2 Rw2
Fw2 U2 Rw2 D B2 L2 Bw2 D2 B2 Bw2 D' Bw2 D2 B2 Rw2
Fw2 U2 Rw2 D B2 L2 Bw2 D2 B2 Fw2 U' Fw2 D2 B2 Rw2
Fw2 U2 Lw2 U F2 L2 Bw2 D2 F2 Fw2 D' Bw2 U2 F2 Lw2
Fw2 U2 Lw2 U F2 L2 Bw2 D2 F2 Bw2 U' Fw2 U2 F2 Lw2
Fw2 U2 Lw2 U F2 L2 Fw2 U2 F2 Fw2 U' Fw2 U2 F2 Lw2
Fw2 U2 Lw2 U F2 L2 Fw2 U2 F2 Bw2 D' Bw2 U2 F2 Lw2
Bw2 D2 Lw2 U B2 R2 Fw2 D2 B2 Bw2 D' Bw2 D2 B2 Rw2
Bw2 D2 Lw2 U B2 R2 Fw2 D2 B2 Fw2 U' Fw2 D2 B2 Rw2
Bw2 D2 Lw2 U B2 R2 Bw2 U2 B2 Bw2 U' Fw2 D2 B2 Rw2
Bw2 D2 Lw2 U B2 R2 Bw2 U2 B2 Fw2 D' Bw2 D2 B2 Rw2
Bw2 D2 Rw2 D F2 R2 Bw2 U2 F2 Fw2 U' Fw2 U2 F2 Lw2
Bw2 D2 Rw2 D F2 R2 Bw2 U2 F2 Bw2 D' Bw2 U2 F2 Lw2
Bw2 D2 Rw2 D F2 R2 Fw2 D2 F2 Fw2 D' Bw2 U2 F2 Lw2
Bw2 D2 Rw2 D F2 R2 Fw2 D2 F2 Bw2 U' Fw2 U2 F2 Lw2

For (seq2000): Rw2 Uw U S Lw2 2U2 2R 2U2 Lw2 S' U' Uw' Rw2
Rw2 U2 R2 Rw' U2 D2 L' Lw U2 D2 Rw' U2 Rw2
Rw2 U2 R2 Rw' U2 D2 L' Rw B2 F2 Lw' D2 Lw2
Rw2 U2 R2 Lw' B2 F2 L' Lw B2 F2 Lw' D2 Lw2
Rw2 U2 R2 Lw' B2 F2 L' Rw D2 U2 Rw' D2 Lw2
Lw2 D2 R2 Rw' D2 U2 L' Lw D2 U2 Rw' D2 Lw2
Lw2 D2 R2 Rw' D2 U2 L' Rw F2 B2 Lw' U2 Rw2
Lw2 D2 R2 Lw' F2 B2 L' Lw F2 B2 Lw' U2 Rw2
Lw2 D2 R2 Lw' F2 B2 L' Rw U2 D2 Rw' U2 Rw2

Almost all of these optimal solves show significant structure.

I should probably make my untwister recognize and reformat explicit
commutators and conjugates.

I've finished depth 15 for a few of these positions, and am starting
depth 16. I don't think I will be able to complete a depth-16 solve for
any of these in any reasonable amount of time; my depth-15 searches
for some of these took about half a day, and the others may take
longer.
 
Last edited by a moderator:
Joined
Oct 31, 2008
Messages
269
Likes
14
Here's a pretty one that just finished. The first solution only moves from two faces,
U and F. Length-16 optimal in OBTM.

Code:
For (seq1022):  F L 2D' L' U' L 2D L' U F' L B 2U B' U' B 2U' B' U L' 
U Fw2 U' F2 U2 F2 U' Fw2 U Fw2 U' F2 U2 F2 U' Fw2
U Fw2 U' F2 U2 F2 U' Fw2 U Bw2 D' F2 D2 F2 D' Bw2
U Fw2 U' F2 U2 F2 U' Bw2 D Fw2 D' F2 D2 F2 D' Bw2
U Fw2 U' F2 U2 F2 U' Bw2 D Bw2 U' F2 U2 F2 U' Fw2
U Bw2 D' F2 D2 F2 D' Fw2 D Fw2 D' F2 D2 F2 D' Bw2
U Bw2 D' F2 D2 F2 D' Fw2 D Bw2 U' F2 U2 F2 U' Fw2
U Bw2 D' F2 D2 F2 D' Bw2 U Fw2 U' F2 U2 F2 U' Fw2
U Bw2 D' F2 D2 F2 D' Bw2 U Bw2 D' F2 D2 F2 D' Bw2
Alg.garron doesn't show the algs properly for me - can someone please post images for these (e.g. http://cube.crider.co.uk/visualcube...U2R2Rw'U2D2L'LwU2D2Rw'U2Rw2&fmt=png&view=plan)? Or put them on the wiki somewhere? The few I've actually executed on a real cube are really cool, though.
Here you go. I had to make a lot of changes since everyone seems to support
their own subset of notations and the like, but I think it works now. I'm
using the cool cube.crider.co.uk to get images, and the excellent alg.cubing.net
to get playback. Thanks to both for their wonderful code!

http://tomas.rokicki.com/ell4x4.html
 
Last edited by a moderator:
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #244
Here you go. I had to make a lot of changes since everyone seems to support
their own subset of notations and the like, but I think it works now. I'm
using the cool cube.crider.co.uk to get images, and the excellent alg.cubing.net
to get playback. Thanks to both for their wonderful code!

http://tomas.rokicki.com/ell4x4.html
I like that "exploded cube view" there, it's the nicest one I have seen.
 
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #245
You just lowered the BHTM for this case by 1 move, the BQTM by 1 move, and the OBTM by 5 moves! It also works on the nxnxn! How did I miss this?!
Rw2 U2 R r' E2 r E2 Rw' U2 Rw2

Now, I'm wondering...

Single Dedge Flip (Current minimum, 19 OBTM)
Rw2 B r B U2 B' r' B U2 Lw' B2 r' B2 Lw B2 Rw2
Rw2 B' r B' U2 B r' B' U2 Lw' B2 r' B2 Lw B2 Rw2

Double Parity (Current minimum, 21 OBTM)
Rw2 U B2 U' r' U B2 U' Rw r U B2 U r' U' B2 U' Rw

Adjacent Double Parity (Current minimum, 22 OBTM)
r2 F Rw' F' r2 U2 r' U2 r' U2 r' U2 F Rw F' r2

Adjacent checkerboard case (Current minimum, 22 OBTM)
Rw' F2 M2 F U2 l U2 l2 U2 l U2 l F' M2 F2 Rw

Adjacent hourglass case (Current minimum, 22 OBTM)
(Lw' U2 M2 U' x) r' U2 r' U2 r2 U2 r' U2 (x' U M2 U2 Lw)


Lastly, algs for all 6 unique "oriented" 3-cycle and 2-cycle last layer cases:
Here's a position I have not seen on any list, including...

http://www.speedsolving.com/wiki/index.php/4x4x4_Parity_Algorithms

 
Joined
Sep 17, 2009
Messages
901
Likes
45
Location
New Orleans, LA
YouTube
4EverTrying
I guess you meant to say algorithm instead of position (I don't list mirror cases because it would take up too much room and it's harder to maintain). Yeah, that's a nice list of 14 movers. I only listed all optimal half turn single slice algorithms for the single dedge flip case on that page (well, I excluded a handful but I explained why), but if I can add any of these algorithms if anyone wants me to. In fact, maybe I should add all of them since the promise of the page (by qqwref, who actually started it) is to list all efficient solutions.

It would really be interesting if you searched for this position: r B2 l' D2 l' B2 r2 B2 U2 l' D2 l U2 l2 B2, which I have algs listed for here.

I used Cube Explorer, and I only got two unique (25,15) solutions, but I'm really curious to see if your solver can find all possible algorithms which are up to 17 moves in length, because, I want to see if your solver can spit out solutions like:
l r F2 l B u' B D2 B' u B r' D2 B2 l2 F2 r' (23,17), as well as all other 23q's and 24q's which are not confined to the moveset <U2,F2,D2,B2,l,r>.

I also found all of these type of algorithms, which are listed for that case, using Cube Explorer, but I didn't do an exhaustive search of depth 17 (I got too tired...I could easily now write a program which goes through a list of all of Cube Explorer's algs to detect if they actually solve the case without having to manually check them like I did for these algorithms, but I want to give your solver some practice!). I had (maybe have a huge list of 17 movers...I think there were only a handful of 16 movers, and as I have said, only 2 15 movers), but I didn't list any of the 17 movers except the ones at the bottom of the list and those which had fewer than 25 quarter turns.
 
Last edited:
Joined
Dec 18, 2007
Messages
7,830
Likes
33
Location
a <script> tag near you
WCA
2006GOTT01
YouTube
qqwref2
Here you go. I had to make a lot of changes since everyone seems to support
their own subset of notations and the like, but I think it works now. I'm
using the cool cube.crider.co.uk to get images, and the excellent alg.cubing.net
to get playback. Thanks to both for their wonderful code!

http://tomas.rokicki.com/ell4x4.html
Awesome! Thanks a lot!


And it's very cool to see these programs getting good enough to generate optimal positions to tricky cases. Any possibility of a qtm solver? :D


unsolved: Would you consider some kind of cube-net view, such as http://www.dembot.net/images/rubik.jpg? Your current view works, but it's a bit hard to convert into a 3D view in my head, and I have a lot of trouble telling which edge sticker connects to which other edge sticker.
 
Joined
Sep 17, 2009
Messages
901
Likes
45
Location
New Orleans, LA
YouTube
4EverTrying
You just lowered the BHTM for this case by 1 move, the BQTM by 1 move, and the OBTM by 5 moves! It also works on the nxnxn! How did I miss this?!
Rw2 U2 R r' E2 r E2 Rw' U2 Rw2
I can't believe I didn't notice this, but, Tom, actually have a (15q, 9 btm) algorithm(s) here!
Rw2 U2 r' E2 r E2 r' U2 Rw2

So it turns out to be equal in btm length to (r U2)4 r, and it only affects two dedges instead of four! (Is this the new and improved quick parity fix?). I believe Kirjava asked me to find an algorithm like this in the past. I hope he's seeing this!

I will definitely add these to the wiki and modify the "minimum move count" table section, but I will first wait a few more days to see if you (Tom) find any new solutions (even if they are not optimal or are equal in length to my algs) and also for cuBerBruce and unsolved to find solutions.

Lastly, Tom, if you adjust your solver to find the optimal OBTM solutions for this case, Uw Lw' Uw' l' Uw Lw Fw' Lw2 Uw' l' Uw Lw' L' Fw Uw' (17 OBTM, one of the current shortest algorithms for this case), then you could very well have a solver which can find the optimal BQTM solution for the single dedge flip case!
 
Last edited:
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #249
unsolved: Would you consider some kind of cube-net view, such as http://www.dembot.net/images/rubik.jpg? Your current view works, but it's a bit hard to convert into a 3D view in my head, and I have a lot of trouble telling which edge sticker connects to which other edge sticker.
At present, each view is as if you rotated the cube to stare right at the 2D face. Top is as viewing with UFR as the 3 visible sides. Front is the same as in that view, so the bottom 4 white cubes attach to the top 4 red ones. I can make the change easy enough, if others say that is what they would want also.


I guess you meant to say algorithm instead of position (I don't list mirror cases because it would take up too much room and it's harder to maintain). Yeah, that's a nice list of 14 movers. I only listed all optimal half turn single slice algorithms for the single dedge flip case on that page (well, I excluded a handful but I explained why), but if I can add any of these algorithms if anyone wants me to. In fact, maybe I should add all of them since the promise of the page (by qqwref, who actually started it) is to list all efficient solutions.

It would really be interesting if you searched for this position: r B2 l' D2 l' B2 r2 B2 U2 l' D2 l U2 l2 B2, which I have algs listed for here.

I used Cube Explorer, and I only got two unique (25,15) solutions, but I'm really curious to see if your solver can find all possible algorithms which are up to 17 moves in length, because, I want to see if your solver can spit out solutions like:
l r F2 l B u' B D2 B' u B r' D2 B2 l2 F2 r' (23,17), as well as all other 23q's and 24q's which are not confined to the moveset <U2,F2,D2,B2,l,r>.

I also found all of these type of algorithms, which are listed for that case, using Cube Explorer, but I didn't do an exhaustive search of depth 17 (I got too tired...I could easily now write a program which goes through a list of all of Cube Explorer's algs to detect if they actually solve the case without having to manually check them like I did for these algorithms, but I want to give your solver some practice!). I had (maybe have a huge list of 17 movers...I think there were only a handful of 16 movers, and as I have said, only 2 15 movers), but I didn't list any of the 17 movers except the ones at the bottom of the list and those which had fewer than 25 quarter turns.
My solver stops after the iteration of a proven optimal solve, but I have variables which can have it search longer. The problem is, on longer depths than the optimal, at the tail end of a solution it starts making moves that "oversolve," and the TFS databases just undo that last move. So say your solution was [....] then the next iteration the program adds R' to the end of it, well the first move in the TFS will be R and the rest of the solution just follows from there. So you get 33 times as many "solutions" at each subsequent depth. You can go from 10 optimal solves at depth N, to 330 at N+1, to over 10,000 at N+2.

By the way, why don't you just download it and run it for yourself?
 
Last edited:
Joined
Oct 31, 2008
Messages
269
Likes
14
have a (15q, 9 btm) algorithm(s) here!
Rw2 U2 r' E2 r E2 r' U2 Rw2
Yeah, I noticed that; I think I'm going to modify my solver or
untwister to collapse move sequences like that that have a
concise name, but aren't actually in the set of moves the
solver is considering.

I think my solver is running out of steam on some of those positions;
I can tell you for sure most are depth 16 or more in the OBTM and
*maybe* we'll get solutions in the next few days, but the programs
have been silent and the node count has been increasing.

I've been doing some thinking and I believe I now understand the
interest in single-slice-turn metric. It's not too far off what cubers
use in general; at 36 moves it has a slightly larger ply than OBTM
(which has 27) but a much smaller ply than the general BTM (at 54!);
and it has a very nice structural+color prune heuristic that's very
deep. Put these together and it appears to be a very nice metric
indeed!

I will be modifying my optimal solver to support SSTM and BTM and
we'll see what happens. I'd be curious to put together a sample of
random-but-solvable positions in the various metrics and doing a
bake-off of our various programs. Of course each has distinct
advantages, but it would be interesting just to compare node count
and node generation rate.

I'm enjoying this thread immensely, by the way; thank you for
starting it all off, unsolved!
 
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #251
I'm enjoying this thread immensely, by the way; thank you for
starting it all off, unsolved!
No problem at all! And thanks everyone for being patient with me, I promise, it has finally paid off. My program, on "normal" hardware, with a new pruning algorithm, can now solve the single dedge flip in 15 minutes flat.



The 6th-ply is a little slow, because it is accumulating some pruning data to be used subsequently. Ply-7 finishes in a blink, and ply-8 motors by. Of course, these are really plies 7 to 13 and 8 to 14 if you have the 6-TFS loaded in RAM.

Code:
TOP                     FRONT                   RIGHT
---------------------   ---------------------   ---------------------
|####|####|####|####|   |OOOO|####|####|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------
|####|####|####|####|   |OOOO|OOOO|OOOO|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------
|####|####|####|####|   |OOOO|OOOO|OOOO|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------
|####|OOOO|OOOO|####|   |OOOO|OOOO|OOOO|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------


BOTTOM                  BACK                    LEFT
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|&&&&|&&&&|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|&&&&|&&&&|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|&&&&|&&&&|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|&&&&|&&&&|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------


Solution [001] =  U2 l2 U2 F2 l  F2 l' F2 l2 [inside 6-TFS] ---> U2 r  U2 r' F2 l   @ 0000406465872 nodes with 0006985517899 6-TFS probes   
Solution [002] =  D2 r2 F2 r  F2 r' F2 D2 r2 [inside 6-TFS] ---> D2 r' F2 l  D2 l'  @ 0001824428262 nodes with 0013045561714 6-TFS probes   
Solution [003] =  D2 l2 F2 l' F2 l  F2 D2 l2 [inside 6-TFS] ---> D2 l  F2 r' D2 r   @ 0001844715291 nodes with 0013132289376 6-TFS probes   
Solution [004] =  r  F2 r' F2 l  B2 r2 B2 D2 [inside 6-TFS] ---> l  B2 r' B2 l2 D2  @ 0002432573235 nodes with 0015644898845 6-TFS probes   
Solution [005] =  r  F2 l' U2 l  U2 r2 F2 r' [inside 6-TFS] ---> F2 r  F2 U2 r2 U2  @ 0002433795581 nodes with 0015650127901 6-TFS probes   
Solution [006] =  r  B2 r' U2 r  U2 l2 B2 r' [inside 6-TFS] ---> U2 l  U2 F2 l2 F2  @ 0002506684772 nodes with 0015961661391 6-TFS probes   
Solution [007] =  r  B2 l' B2 l  D2 l2 D2 B2 [inside 6-TFS] ---> r  D2 l' D2 r2 B2  @ 0002508549198 nodes with 0015969630617 6-TFS probes   
Solution [008] =  r' U2 r  U2 l' D2 r2 D2 B2 [inside 6-TFS] ---> l' D2 r  D2 l2 B2  @ 0002522780481 nodes with 0016030397406 6-TFS probes   
Solution [009] =  r' U2 l  F2 l' F2 r2 U2 r  [inside 6-TFS] ---> U2 r' U2 F2 r2 F2  @ 0002524884073 nodes with 0016039380665 6-TFS probes   
Solution [010] =  r' D2 r  F2 r' F2 l2 D2 r  [inside 6-TFS] ---> F2 l' F2 U2 l2 U2  @ 0002596731391 nodes with 0016346481888 6-TFS probes   
Solution [011] =  r' D2 l  D2 l' B2 l2 B2 D2 [inside 6-TFS] ---> r' B2 l  B2 r2 D2  @ 0002597956752 nodes with 0016351719712 6-TFS probes   
Solution [012] =  r2 U2 l  B2 l' B2 U2 l' U2 [inside 6-TFS] ---> r  B2 r' B2 U2 r2  @ 0002747524641 nodes with 0016990985473 6-TFS probes   
Solution [013] =  r2 U2 B2 r  B2 r' U2 l  U2 [inside 6-TFS] ---> B2 l  B2 l' U2 r2  @ 0002751046563 nodes with 0017006008250 6-TFS probes   
Solution [014] =  r2 D2 r' F2 r  F2 D2 r  D2 [inside 6-TFS] ---> l' F2 l  F2 D2 r2  @ 0002825128098 nodes with 0017322600433 6-TFS probes   
Solution [015] =  r2 D2 F2 l' F2 l  D2 r' D2 [inside 6-TFS] ---> F2 r' F2 r  D2 r2  @ 0002827829850 nodes with 0017334167141 6-TFS probes   
Solution [016] =  r2 F2 D2 r' D2 r  F2 l' F2 [inside 6-TFS] ---> D2 l' D2 l  F2 r2  @ 0002881673268 nodes with 0017564313609 6-TFS probes   
Solution [017] =  r2 F2 l' D2 l  D2 F2 l  F2 [inside 6-TFS] ---> r' D2 r  D2 F2 r2  @ 0002884748805 nodes with 0017577468407 6-TFS probes   
Solution [018] =  r2 B2 U2 l  U2 l' B2 r  B2 [inside 6-TFS] ---> U2 r  U2 r' B2 r2  @ 0002960641173 nodes with 0017901912452 6-TFS probes   
Solution [019] =  r2 B2 r  U2 r' U2 B2 r' B2 [inside 6-TFS] ---> l  U2 l' U2 B2 r2  @ 0002962953789 nodes with 0017911794185 6-TFS probes   
Solution [020] =  l  U2 r' F2 r  F2 l2 U2 l' [inside 6-TFS] ---> U2 l  U2 F2 l2 F2  @ 0002979990728 nodes with 0017984693002 6-TFS probes   
Solution [021] =  l  U2 l' U2 r  D2 l2 D2 B2 [inside 6-TFS] ---> r  D2 l' D2 r2 B2  @ 0002981197491 nodes with 0017989861581 6-TFS probes   
Solution [022] =  l  D2 r' D2 r  B2 r2 B2 D2 [inside 6-TFS] ---> l  B2 r' B2 l2 D2  @ 0003052273770 nodes with 0018293833975 6-TFS probes   
Solution [023] =  l  D2 l' F2 l  F2 r2 D2 l' [inside 6-TFS] ---> F2 r  F2 U2 r2 U2  @ 0003053791577 nodes with 0018300315731 6-TFS probes   
Solution [024] =  l' F2 r  U2 r' U2 l2 F2 l  [inside 6-TFS] ---> F2 l' F2 U2 l2 U2  @ 0003273128257 nodes with 0019237753588 6-TFS probes   
Solution [025] =  l' F2 l  F2 r' B2 l2 B2 D2 [inside 6-TFS] ---> r' B2 l  B2 r2 D2  @ 0003274758399 nodes with 0019244714236 6-TFS probes   
Solution [026] =  l' B2 r  B2 r' D2 r2 D2 B2 [inside 6-TFS] ---> l' D2 r  D2 l2 B2  @ 0003347037486 nodes with 0019553798611 6-TFS probes   
Solution [027] =  l' B2 l  U2 l' U2 r2 B2 l  [inside 6-TFS] ---> U2 r' U2 F2 r2 F2  @ 0003348060802 nodes with 0019558169258 6-TFS probes   
Solution [028] =  l2 U2 r' B2 r  B2 U2 r  U2 [inside 6-TFS] ---> l' B2 l  B2 U2 l2  @ 0003364198932 nodes with 0019627163938 6-TFS probes   
Solution [029] =  l2 U2 B2 l' B2 l  U2 r' U2 [inside 6-TFS] ---> B2 r' B2 r  U2 l2  @ 0003369490926 nodes with 0019649801644 6-TFS probes   
Solution [030] =  l2 D2 l  F2 l' F2 D2 l' D2 [inside 6-TFS] ---> r  F2 r' F2 D2 l2  @ 0003443109375 nodes with 0019964366824 6-TFS probes   
Solution [031] =  l2 D2 F2 r  F2 r' D2 l  D2 [inside 6-TFS] ---> F2 l  F2 l' D2 l2  @ 0003444731127 nodes with 0019971291358 6-TFS probes   
Solution [032] =  l2 F2 D2 l  D2 l' F2 r  F2 [inside 6-TFS] ---> D2 r  D2 r' F2 l2  @ 0003473351547 nodes with 0020093607115 6-TFS probes   
Solution [033] =  l2 F2 r  D2 r' D2 F2 r' F2 [inside 6-TFS] ---> l  D2 l' D2 F2 l2  @ 0003473844888 nodes with 0020095711385 6-TFS probes   
Solution [034] =  l2 B2 U2 r' U2 r  B2 l' B2 [inside 6-TFS] ---> U2 l' U2 l  B2 l2  @ 0003550753275 nodes with 0020424406989 6-TFS probes   
Solution [035] =  l2 B2 l' U2 l  U2 B2 l  B2 [inside 6-TFS] ---> r' U2 r  U2 B2 l2  @ 0003554860137 nodes with 0020441962628 6-TFS probes   
Solution [036] =  F2 r2 F2 U2 r  U2 r' U2 r2 [inside 6-TFS] ---> F2 l  F2 l' U2 r   @ 0004208077860 nodes with 0023234154839 6-TFS probes   
Solution [037] =  F2 l2 F2 U2 l' U2 l  U2 l2 [inside 6-TFS] ---> F2 r' F2 r  U2 l'  @ 0004233105906 nodes with 0023341109196 6-TFS probes   
Solution [038] =  B2 r2 U2 r' U2 r  U2 B2 r2 [inside 6-TFS] ---> B2 r  U2 l' B2 l   @ 0005675301648 nodes with 0029506158594 6-TFS probes   
Solution [039] =  B2 l2 U2 l  U2 l' U2 B2 l2 [inside 6-TFS] ---> B2 l' U2 r  B2 r'  @ 0005696510847 nodes with 0029596830064 6-TFS probes
 
Last edited:
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #252
I can't believe I didn't notice this, but, Tom, actually have a (15q, 9 btm) algorithm(s) here!
Rw2 U2 r' E2 r E2 r' U2 Rw2

So it turns out to be equal in btm length to (r U2)4 r, and it only affects two dedges instead of four! (Is this the new and improved quick parity fix?). I believe Kirjava asked me to find an algorithm like this in the past. I hope he's seeing this!

I will definitely add these to the wiki and modify the "minimum move count" table section, but I will first wait a few more days to see if you (Tom) find any new solutions (even if they are not optimal or are equal in length to my algs) and also for cuBerBruce and unsolved to find solutions.

Lastly, Tom, if you adjust your solver to find the optimal OBTM solutions for this case, Uw Lw' Uw' l' Uw Lw Fw' Lw2 Uw' l' Uw Lw' L' Fw Uw' (17 OBTM, one of the current shortest algorithms for this case), then you could very well have a solver which can find the optimal BQTM solution for the single dedge flip case!
I can't believe I didn't notice this, but, Tom, actually have a (15q, 9 btm) algorithm(s) here!
Rw2 U2 r' E2 r E2 r' U2 Rw2

So it turns out to be equal in btm length to (r U2)4 r, and it only affects two dedges instead of four! (Is this the new and improved quick parity fix?). I believe Kirjava asked me to find an algorithm like this in the past. I hope he's seeing this!

I will definitely add these to the wiki and modify the "minimum move count" table section, but I will first wait a few more days to see if you (Tom) find any new solutions (even if they are not optimal or are equal in length to my algs) and also for cuBerBruce and unsolved to find solutions.

Lastly, Tom, if you adjust your solver to find the optimal OBTM solutions for this case, Uw Lw' Uw' l' Uw Lw Fw' Lw2 Uw' l' Uw Lw' L' Fw Uw' (17 OBTM, one of the current shortest algorithms for this case), then you could very well have a solver which can find the optimal BQTM solution for the single dedge flip case!
Solved this one in about 5 seconds.

Code:
Solutions To Scramble = R2 r2 U2 r' u2 d2 r u2 d2 r' U2 R2 r2 

TOP                     FRONT                   RIGHT
---------------------   ---------------------   ---------------------
|####|OOOO|&&&&|####|   |OOOO|####|####|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------
|####|####|####|####|   |OOOO|OOOO|OOOO|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------
|####|####|####|####|   |OOOO|OOOO|OOOO|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------
|####|OOOO|&&&&|####|   |OOOO|OOOO|OOOO|OOOO|   |XXXX|XXXX|XXXX|XXXX|
---------------------   ---------------------   ---------------------


BOTTOM                  BACK                    LEFT
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|####|####|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|&&&&|&&&&|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|&&&&|&&&&|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------
|~~~~|~~~~|~~~~|~~~~|   |&&&&|&&&&|&&&&|&&&&|   |^^^^|^^^^|^^^^|^^^^|
---------------------   ---------------------   ---------------------



Solution [001] =  r2 U2 r  u2 d2 [inside 6-TFS] ---> r' d2 u2 r  U2 r2  @ 0000011178567 nodes with 0000051385399 6-TFS probes   
Solution [002] =  r2 D2 l  U2 D2 [inside 6-TFS] ---> r' D2 U2 l  D2 r2  @ 0000011373123 nodes with 0000052213073 6-TFS probes   
Solution [003] =  r2 D2 l  u2 d2 [inside 6-TFS] ---> l' d2 u2 l  D2 r2  @ 0000011373210 nodes with 0000052213548 6-TFS probes   
Solution [004] =  l2 U2 l  U2 D2 [inside 6-TFS] ---> r' D2 U2 l  U2 l2  @ 0000013039131 nodes with 0000059331529 6-TFS probes   
Solution [005] =  l2 U2 l  u2 d2 [inside 6-TFS] ---> l' d2 u2 l  U2 l2  @ 0000013039218 nodes with 0000059331911 6-TFS probes   
Solution [006] =  l2 D2 r  U2 D2 [inside 6-TFS] ---> l' D2 U2 r  D2 l2  @ 0000013228752 nodes with 0000060138361 6-TFS probes   
Solution [007] =  l2 D2 r  u2 d2 [inside 6-TFS] ---> r' d2 u2 r  D2 l2  @ 0000013228839 nodes with 0000060138726 6-TFS probes
 
Joined
Oct 8, 2006
Messages
914
Likes
15
Location
Malden, MA, USA
WCA
2006NORS01
YouTube
cuBerBruce
I will be modifying my optimal solver to support SSTM and BTM and
we'll see what happens. I'd be curious to put together a sample of
random-but-solvable positions in the various metrics and doing a
bake-off of our various programs. Of course each has distinct
advantages, but it would be interesting just to compare node count
and node generation rate.
I might suggest also doing apples-to-apples comparisons of the same program on different hardware. Unsolved's program on my computer appeared to be much slower than on his, but it wasn't running the same position and using the same TFS database. But still, it makes me wonder if my computer was emulating instructions that his was performing in hardware or something like that. I also know that it was running on a single thread on my computer, and if programs make use of parallel execution, I would like to have some way of controlling how many threads will be used. My program is not currently multithreaded, so I think side-by-side comparisons should also take number of threads into consideration. Assuming there is a big difference in execution speed, I am curious what is causing the difference in speed to be so big.

I also note that my program runs on 32-bit Windows, while unsolved's executable is a 64-bit executable and won't run on a 32-bit machine. I might try making 64-bit executables just to see if that has any effect on the performance on 64-bit machines. But I would also be using a different compiler to do that.

I've also been thinking of using a fixed DLB model like Tom is doing. It seemed convenient at first to simply apply the actual moves so that no tricky translation of the moves are needed. Right now my program (working with a copy of the cube's state) has to find the DLB cubie, and then apply cube rotations that put that cubie into its solved location and orientation. But I also use a couple of other corners as reference when doing pruning table lookups, and these would seem not to benefit at all in using a fixed DLB model. Maybe I should be tracking the necessary state info separately for each combination of pruning table and reference piece?
 
Last edited:
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #254
I might suggest also doing apples-to-apples comparisons of the same program on different hardware. Unsolved's program on my computer appeared to be much slower than on his, but it wasn't running the same position and using the same TFS database. But still, it makes me wonder if my computer was emulating instructions that his was performing in hardware or something like that. I also know that it was running on a single thread on my computer, and if programs make use of parallel execution, I would like to have some way of controlling how many threads will be used. My program is not currently multithreaded, so I think side-by-side comparisons should also take number of threads into consideration. Assuming there is a big difference in execution speed, I am curious what is causing the difference in speed to be so big.

I also note that my program runs on 32-bit Windows, while unsolved's executable is a 64-bit executable and won't run on a 32-bit machine. I might try making 64-bit executables just to see if that has any effect on the performance on 64-bit machines. But I would also be using a different compiler to do that.

I've also been thinking of using a fixed DLB model like Tom is doing. It seemed convenient at first to simply apply the actual moves so that no tricky translation of the moves are needed. Right now my program (working with a copy of the cube's state) has to find the DLB cubie, and then apply cube rotations that put that cubie into its solved location and orientation. But I also use a couple of other corners as reference when doing pruning table lookups, and these would seem not to benefit at all in using a fixed DLB model. Maybe I should be tracking the necessary state info separately for each combination of pruning table and reference piece?
You have to understand, at the office, I have access to systems running at speeds up to 5.40 GHz and at temperatures of -42 degrees Fahrenheit.



So they will be finding solves pretty fast, even with an inefficient array-based move generator.

I had to finally give up on my massively parallel version. Warning, this next screen shot shows me being mad and placing a few curses in my debugging...


I am not sure why the code would peg my 32-threaded hardware and then produce all kinds of errors when doing corner pruning.

The single-threaded, multi-core aware code seems most stable, and I will be making it available soon.
 
Last edited:
Joined
Feb 9, 2009
Messages
1,910
Likes
10
WCA
2008ANDE02
YouTube
Minxer2011
You have to understand, at the office, I have access to systems running at speeds up to 5.40 GHz and at temperatures of -42 degrees Fahrenheit.



So they will be finding solves pretty fast, even with an inefficient array-based move generator.
Looks more like cooking equipments than a computer.
 
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #257
That's pretty awesome - maybe you're just gonna have to run the other solver yourself and see how the timings compare :p
And to answer Bruce's other question about why I have a 64-bit only version of the program:

Code:
CUBE_4x4_BITBOARD_ARRANGEMENT double_front_face_bitboard_move(CUBE_4x4_BITBOARD_ARRANGEMENT original)
{
CUBE_4x4_BITBOARD_ARRANGEMENT new = original;

new.cube_face[BITBOARD_TOP_INDEX]    = (original.cube_face[BITBOARD_TOP_INDEX] & BITMASK_CUBE_FACE_NOT_ROW_04) | BIT_TRANSFORM_ROW_1_TO_ROW_4(original.cube_face[BITBOARD_BOTTOM_INDEX] & BITMASK_CUBE_FACE_ROW_01);
new.cube_face[BITBOARD_BOTTOM_INDEX] = (original.cube_face[BITBOARD_BOTTOM_INDEX] & BITMASK_CUBE_FACE_NOT_ROW_01) | BIT_TRANSFORM_ROW_4_TO_ROW_1(original.cube_face[BITBOARD_TOP_INDEX] & BITMASK_CUBE_FACE_ROW_04);
new.cube_face[BITBOARD_LEFT_INDEX]   = (original.cube_face[BITBOARD_LEFT_INDEX]   & BITMASK_CUBE_FACE_NOT_COL_04) | BIT_TRANSFORM_COL_1_TO_COL_4(original.cube_face[BITBOARD_RIGHT_INDEX] & BITMASK_CUBE_FACE_COL_01);
new.cube_face[BITBOARD_RIGHT_INDEX]  = (original.cube_face[BITBOARD_RIGHT_INDEX]  & BITMASK_CUBE_FACE_NOT_COL_01) | BIT_TRANSFORM_COL_4_TO_COL_1(original.cube_face[BITBOARD_LEFT_INDEX] & BITMASK_CUBE_FACE_COL_04);

		/*********************************************************************************/
		/*                                 Rotate the TOP                                */
		/*********************************************************************************/
		/*                                                                               */
		/* THESE CUBE LOCATIONS BECOME....              THESE CUBE LOCATIONS             */
		/*                                                                               */
		/*                                                                               */
		/*********************************/             /*********************************/
		/*  01   *  02   *  03   *   04  */             /*  16   *  15   *  14   *   13  */
		/*********************************/             /*********************************/
		/*  05   *  06   *  07   *   08  */             /*  12   *  11   *  10   *   09  */
		/*********************************/             /*********************************/
		/*  09   *  10   *  11   *   12  */             /*  08   *  07   *  06   *   05  */
		/*********************************/             /*********************************/
		/*  13   *  14   *  15   *   16  */             /*  04   *  03   *  02   *   01  */
		/*********************************/             /*********************************/
		/*                                                                               */
		/*                                                                               */
		/*********************************************************************************/

new.cube_face[BITBOARD_TOP_INDEX] = ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_16) << 60) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_15) << 52) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_14) << 44) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_13) << 36) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_12) << 28) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_11) << 20) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_10) << 12) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_09) << 4)  |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_08) >> 4)  |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_07) >> 12) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_06) >> 20) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_05) >> 28) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_04) >> 36) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_03) >> 44) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_02) >> 52) |\
			                                ((original.cube_face[BITBOARD_FRONT_INDEX] & BITMASK_CUBE_FACE_SQUARE_01) >> 60);

		return new;
}
Technically, I can make any move on the cube using only 5 instruction with 64-bits. You can see the ">>" and "<<" operators are shifting bits as far as 60 slots at a time. You can't do that on a 32-bit computer.
 
Last edited:
Joined
Apr 6, 2009
Messages
1,754
Likes
11
Location
Sweden
WCA
2010JERN01
YouTube
jernqvist
Pretty cool with all those 15 move dedge flips, but as for the display wouldn't having two characters instead of four between make the squares look more, well square? And also just so you know the de facto standard is having green on front and white on top.
 
Joined
Mar 2, 2014
Messages
566
Likes
9
Location
Doylestown, PA
Thread starter #260
Pretty cool with all those 15 move dedge flips, but as for the display wouldn't having two characters instead of four between make the squares look more, well square? And also just so you know the de facto standard is having green on front and white on top.
All reasonable suggestions made by the posters here will be taken into consideration and possibly implemented. The reason I have it so wide is that on my 72 inch monitor, with "just square" squares, they look pinched and too skinny :)

As for the cube colors, they mirror my own 4x4x4 MF8-whatever-that-other-name-was before the stickers started peeling. In fact, one of my prime motivations for writing the program was to be able to finish solves I messed up when applying the algos from here!



That is what my current cube looks like. Somehow, some way, My URb edge is at ULf, UFr is at UBl, ULf is at UFr, and UBl is at URb.

I can't find an algo for this, and it looks like 15 turns is not enough to solve this? Unless my pruning is over-doing it, as Bruce alluded to in an earlier warning, but I thought I took all necessary precautions before implementing it.

UPDATE: Looks like it found it in 16 moves. Can anyone confirm there is no faster solve?
 
Last edited:
Status
Not open for further replies.
Top