• 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 40,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!
Joined
Nov 14, 2020
Messages
329
Location
the space-time continuum
YouTube
Visit Channel
idk if this has been came up with before but for the case solved with R U2 R' U' R U R'(or its mirror), if the edge is misoriented, you can just do the big cube flipping alg, or sledghammer followed by R U' R', or mirrored, and it pairs it up and also flips the edge, which saves a rotation.
 

MethodNeutral

Member
Joined
Jan 4, 2017
Messages
48
For a long time I've been interested in a CP reduction which can be solved by <L,U> followed by <R,U> moves.

To explain it in a different way, take a solved cube and scramble it with <R,U>. Then scramble it with <L,U>. This cube is now in the reduction state I'm interested in. This is nice because the solution is simply to solve the left F2L block (cross + 2 pairs) using LU, then solve the right F2L block in a similar fashion and then 2GLL.

However, reaching a state like this is far from easy to do in inspection, so I came up with a different method idea which uses the same concept. I am referring to this method as LURoux, a pun on the fact that this uses LU->RU reduction.

1. Reduce only the corners of the cube to the above-described LU->RU state (solvable by LU followed by RU).
2. Solve left F2L block in the style of Roux second block.
3. Solve the right F2L block in the style of Roux second block.
4. Solve edge orientation and place DF/DB edges (EODFDB).
5. 2GLL

Essentially, this is ZBRoux but with just 2-gen cases thanks to the initial reduction step.

Step 1 is much easier when we don't have to worry about edge orientation, and for now the method I am using is the same as the first step in the YruRU method. In the future, I am hoping this can be streamlined even further since it is technically even less restrictive than reducing the cube to 2-gen (the DL corners won't necessarily have to be solved at the end of this step, although having them solved makes recognition much easier).

Pros:
  • Ergonomic turning throughout the solve
  • Repeated steps (Two steps are similar to Roux SB, which means the solver gets more practice executing these steps)
  • Reduced algorithm count compared to ZBRoux (84 for 2GLL)
  • While solving EODFDB, lookahead to 2GLL is very easy as the corners case is visible throughout this part of the solve

Cons:
  • Pieces for the first block can become stuck in the second block after solving CP (solvable with R2 S R2 S' or a similar commutator)
  • CP recognition will take practice
  • Higher movecount than ZBRoux (I'm not quite sure how to calculate movecount exactly)

I can post an example solve, although it will not be indicative of how an actual solve would look as the first step is still very undeveloped (as I mentioned earlier, I am just copying the first step of YruRU).

Comparing this method to Roux:
  • Worse first block due to restricted moveset of <L,l,U>
  • Identical second block
  • EODFDB is comparable to EOLR

LURoux has an extra initial step, and then we are comparing 2GLL with Roux's CMLL and step 4c. As a result, I think Roux is objectively better than this method for speedsolving, so I wouldn't recommend using if you're interested in speed. Otherwise, it's a very fun method.

Let me know what you think, and if you have any advice for the LURoux reduction step!

Edit:
Rather than doing LURU reduction via the first step of YruRU, in inspection you can simply find two corners which are permuted correctly since orientation will not matter. I don't know how to calculate the likelihood of this happening, but anecdotally it is very high. It seems like at most, a scramble will require one move to place two adjacent corners next to each other.

Once two adjacent corners are next to each other, they can be treated as the DL corners for YruRU-style reduction. Once the key flip is determined between the other corners, it can be solved via a simple trigger like F R F' / F R' F' / F' U F / F' U' F. From there, the LURU reduction is solved.

In my post, I forgot to mention the solving of the L center in the method. This is done after CP (LURU reduction), as the <L,l,U,u> moveset is available. S slices are also available, but I don't find them as ergonomic. In either case, this is yet another con of the method in the context of speedsolving.
 
Last edited:

MethodNeutral

Member
Joined
Jan 4, 2017
Messages
48
A bit of an update on LURoux: I've developed a better way of performing the reduction step, so here is an outline. I will be using this scramble from cstimer: D2 R2 U B2 R2 D R2 D2 U L2 U F U F2 R' D' B F D

I scrambled with white top green front, and I solve with white on D. So perform the scramble with your D-layer face on U in order to follow along.

0. Find two adjacent D-layer corners which are already adjacent to each other. They do not need to be oriented, nor do they need to be solved relative to each other. For example, on the scramble perform an x rotation and the two corners in DL belong adjacent to each other, but they are not solved relative to each other (this will take familiarity with the color scheme to recognize, although in this case it is obvious as they happen to be oriented).

0.a. If there are no adjacent D-layer corners which can be found next to each other, perform CP as done in the YruRU method. (note: Orientation of DL corners doesn't matter in LURoux, so we are slightly less restricted than we would be in YruRU).

Note that now, assuming we didn't branch into 0.a, the DL corners are either solved or swapped. This will be important later.

1. Determine CP using whatever method you are familiar with. I like to use a modified version of what is taught in the YruRU tutorial (link above).

Now, there is either a key swap of pieces to be performed, or CP is solved.

There are four cases to be considered now:
2.a. DL corners solved, CP solved
2.b. DL corners solved, CP requires a swap
2.c. DL corners swapped, CP solved
2.d. DL corners swapped, CP requires a swap

2.a. Nothing to do here (yay!)

2.b. The key swap can be performed with a simple algorithm such as F' U F or F R F'

2.c. This case is annoying, I handle it with F' U F R (this will be explained later)

2.d. Use 2-gen (R,U) to put the key swap at DR

In case 2.b, the algs I use are F R F' (swaps UB corners), F R' F or F' U F (swaps UR corners), and F' U' F (swaps UF corners).

In case 2.c, we actually create a swap (F' U F) and then solve it as if it's case 2.d (R).

In the scramble we received, I traced CP to find that a swap is needed between the corner at UFL and the corner at DBR, which is equivalent to swapping the two corners at FR positions. As a result, an R' will position these corners at DR to solve the LURoux reduction.

So the solution for this scramble would be something like this:

Scramble: D2 R2 U B2 R2 D R2 D2 U L2 U F U F2 R' D' B F D

Inspection: x
CP: R'
Piece sorting: No moves necessary :)
First block:
Square: M2 U L' U' L' U2 l U l'
Pair: L' U2 L U' L' U L
Second block:
Square: R2 U R U2 r' U' R2
Pair: U M' R' U r
EODFDB: M' U M U2 M' U' M' U' M2 U2 M' U2 M'
2GLL: U R U' R' U2 R U R' U2 R U R' U2 R U2 R'

If anyone is interested, I can show the solution to other scrambles which cover the other possible CP cases (2.a/2.b/2.c). I'm also happy to explain my method for tracing CP if that interests anyone.
 
Top