Contructing Algorithms (not a how to, sorry)

J

jerry

Member
Joined
Aug 6, 2008
Messages
3
Lately I've been interested in understanding more about the cube. I learned the Heise method a while back and was quite happy with it. I like the idea of using commutators to solve certain situations on the spot. However, from my understanding you can't use a commutator to swap two edges and two corners at once (like a T perm would). I don't know any of those permutations because I never bothered memorizing algorithms (I'm not really interested in speed cubing). My goal is to understand how to come up with such permutations on the spot without memorizing them. Is there any method along a vein similar to commutators that could accomplish this?
 
Yes. I have actually invented a method for creating parity algorithms that can help you to swap two edges and two corners.

For example, the parity algorithm:
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

can be written as:

r2 B2 :Set-up moves
l F2 :Set-up moves
F2 l' :Set-up moves
(U2 l U2 r' U2 r U2 l') : The commutator [U2, l U2 r'].
l F2 :Set-up moves
(r) : The extra quarter turn
F2 l' :Set-up moves
B2 r2 :Set-up moves
= [r2 B2: [l F2: [F2 l' : [U2, l U2 r'] ] (r) ] ]

The inner portion,
F2 l' :Set-up moves
(U2 l U2 r' U2 r U2 l') : The commutator [U2, l U2 r'].
l F2 :Set-up moves
(r) : The extra quarter turn

is an "interior J-Perm".
=
F2 l'
(U2 l U2 r' U2 r U2 l')
l F2
(r)
=[F2 l' : [U2, l U2 r'] ] (r)
So, if we translate to the outer slices, lo and behold we have a J-Perm:
F2 L'
(U2 L U2 R' U2 R U2 L')
L F2
(R)

If we shift the following moves from the beginning to the end, we get a T-Perm.
L U2 R' U2 R U2 L'
L F2
R
F2 L' U2 :The moves that were moved here from the beginning.

Note that this is equal to:
U2 L F2
F2 L'
(U2 L U2 R' U2 R U2 L')
L F2
(R)
F2 L' U2

Summary:
Basically we have the form:
B
A
(commutator)
A'
(quarter turn)
B'

Where we:
1) Started with a commutator
2) Applied set-up moves A to it to bring all pieces involved into the R slice
3) Applied a quarter turn to solve back exactly half of the pieces in slice R

Note that steps 1-3 make what I call a "base" algorithm.

4) Applied set-up moves B to Manipulate the remaining messed up pieces like we wish.

This algorithm form is what I call a symmetrical algorithm, because it has a lot of symmetry.

I have an entire thread about creating symmetrical parity algorithms for big cubes. You should check it out, as the idea is the same. I have not finished contributing to that thread yet, but what I have so far is definitely enough for people to get started on constructing common parity algorithms.

Non-symmetrical algorithm
Non-symmetrical algorithms can be composed of a base algorithm (like in symmetrical algorithms) + another algorithm piece. Non-symmetrical algorithms do not have symmetry. An example is a J-perm you may use as your primary algorithm:
R U2 R' U' R U2 L' U R' U' L

This algorithm can be written as:
R U set-up moves
(U R' U' R) commutator [U, R']
U' R' set-up moves
(R U' L' U R' U' L U) commutator [R, U' L' U]
(U') quarter turn

= [R U: [U, R'] ] [R, U' L' U] (U')


Clearly, to be able to construct this algorithm by hand, we:
1) Start out with the commutator U R' U' R
2) Add set-up moves R U (and invert them of course)
3) Add a corner commutator
4) Add the extra quarter turn to solve back half of the pieces.

We can also shift this algorithm to get a "y-perm"
R U2 L' U R' U' L
R U2 R' U'

Note that this is equal to
U R U2 R'
R U2 R' U' R U2 L' U R' U' L
R U2 R' U'
 
This is awesome. I'll be messing around with this for a bit. I appreciate it man, thanks. :tu
 
No problem. I am glad I could help.

Note that it took ingenuity for me to decompose the non-symmetrical algorithm. So, if there is a non-symmetrical algorithm you wish to understand (at least its structure), you need to have the patience to write equivalences of it until you get familiar pieces. Remember, computer solvers don't tell you that they canceled a lot of moves: they just give you the final solution (with moves canceled). Transformations of algorithms may also be a good technique for simplifying the form of complex algorithms.

A good example of a computer-made non-symmetrical algorithm I decomposed was the optimal algorithm to swap two diagonal corners on a 4x4x4:
Rw2 f2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 R2 U2 F2 Rw2 U

After countless pages of work, I finally decomposed it to:
Rw2 F2 U2 r2 __________________________Preliminary
r2 ___________________________________ Extra turn to induce PLL Parity
U2 Fw2 U2 Fw2 U' Rw2 U2 Fw2 U Fw2 Rw2 ___Base
r2 U2 F2 Rw2 __________________________Reverse of Preliminary
U ____________________________________Finishing turn to make pure

Just as I hope we can learn from computer algorithms, I made my own algorithm to do the same thing. It was only one half turn move more, but the quarter turn move count was the same:
Rw2 F2 U2 y Rw2 U' Rw2 U D Lw2' U' Lw2' y' r2 U2 F2 Rw2 U

Its outline is:
Rw2 F2 U2 r2 ________________________Preliminary moves
r2 ____________ _____________________ Extra turn to induce PLL Parity
y z' Uw2 L' Uw2 L R Uw2 R' Uw2 z y' _______Base
r2 U2 F2 Rw2 _________________________Reverse of preliminary.
U __________________________________Finishing turn to make pure

So, an important note is that non-symmetrical algorithms can also be a symmetrical algorithm which needs one or more additional turns to restore the cube. So watch out for those as well.
 
Last edited:
Lucas Garron asked me to find good explanations to the following four brief J-Perms if I could.

L' U R U' L U2 R' U R U2 R'
R U R' F' R U R' U' R' F R2 U' R' U'
B2 R2 U' R2 U R2 D' R2 D B2 U'
F2 L' U' L F2 R' D R' D' R2

It is definitely relevant to this thread.


Algorithm #1:
(Non-symmetrical structure)
L' U R U' L U2 R' U R U2 R'= [R : [L', R' U R U'] [U2 R': [R U2: [R' , U] ] (U)]

A much easier derivation is in my next post. This approach is valid, but not so simple compared to the alternative!
Derivation
1) Start with the commutator [R' , U].

[R' , U]

2) Add the set-up moves R U2 to bring all edges in the top layer (oriented).

R U2
[R' , U]
U2 R'

3) Add the quarter turn (U) to solve back two of the three edges currently out of place (and pull the one solved out). Now we have a 4-cycle of corners and a 2-cycle of edges.

R U2
[R',U]
U2 R'
(U)

4) Add the set-up moves U2 R' (or just shift the first two moves) to set-up for a corner commutator that we can cancel a lot of moves with. (unobvious, but...)

U2 R'
R U2
[R' , U]
U2 R'
(U)
R U2

5) Now we can add the corner commutator [L', R' U R U'] to have only two corners and two edges swapped (well, a center 90 degrees, but...)

U2 R'
R U2
[R' , U]
U2 R'
(U)
R U2
[L', R' U R U']

6) Shift the entire corner commutator backwards to have a different pair of corners affected for minimal set-up moves to finish off the algorithm.

[L', R' U R U']
U2 R'
R U2
[R' , U]
U2 R'
(U)
R U2

7) Add the set-up move R to complete the algorithm.

R
[L', R' U R U']
U2 R'
R U2
[R' , U]
U2 R'
(U)
R U2
R'

=
R
L' R' U R U' L U R' U' R
U2 R'
R U2
R' U R U'
U2 R'
(U)
R U2
R'

8) Cancel moves to achieve the algorithm.


Algorithm #2:
(Non-symmetrical structure)
R U R' F' R U R' U' R' F R2 U' R' U' = [U: (U') [R U R' : [F' , R U R' U' R'] [R, U] ]]

Derivation
1) Start with the commutator [U, R]

[U, R]

2) Add the corner commutator [R U R' U' R', F'] so that only three complete 1x2 blocks are affected. This is very much related to how the j-perm for the "standard edge flip algorithm" is made, except here we are using two commutators instead of one to cycle three 1x2 blocks.

[U, R]
[R U R' U' R', F']

3) Add the set-up moves R U R', one at a time to see how to move all 1x2 blocks into the top layer (oriented).

R U R'
[U, R]
[R U R' U' R', F']
R U' R'

4) Add a quarter turn, U
R U R'
[U, R]
[R U R' U' R', F']
R U' R'
(U)

5) Add the final set-up move, U to move the j-perm over in the top.


U
R U R'
[U, R]
[R U R' U' R', F']
R U' R'
(U)
U'

=
U
R U R'
U R U' R'
R U R' U' R' F' R U R U' R' F
R U' R'
(U)
U'

6) Cancel moves and take the inverse to achieve the algorithm.


Algorithm #3
(Symmetrical structure)

B2 R2 U' R2 U R2 D' R2 D B2 U' = [z': [B2: [U2 L' : [U2, L U2 R'] ] ] ] (U')

Derivation
1) Start with the commutator [U2, L U2 R'] to swap three 1x2 blocks.
This is the same commutator used in the "standard edge flip parity algorithm"

[U2, L U2 R']

2) Add the set-up moves U2 L' (do a backwards shift of two moves)

U2 L'
[U2, L U2 R']
L U2

3) Add a set-up move B2 to put the third block in slice L.

B2
U2 L'
[U2, L U2 R']
L U2
B2

4) Add a quarter turn, L'.

B2
U2 L'
[U2, L U2 R']
L U2
B2
(L')

5) We can rotate it into the top face
=
z'
B2
U2 L' U2 L U2 R' U2 R
B2
(L')
z

6) We can write an equivalent to omit the cube rotations. This produces the algorithm we wish to derive.


Algorithm #4:
(Symmetrical structure)
F2 L' U' L F2 R' D R' D' R2 = [F2 L' : (U)' [L F2 : [R2 : [R, D] ] ] ]


Derivation
1) Start with the commutator [D, R]

[D, R]

2) Add the set-up moves L F2 R2 to move all affected pieces to the top layer.

L F2 R2
[D, R]
R2 F2 L'

3) Now we can add the quarter turn U to have only two edges and two corners swaped (and a center rotated 90 degrees)

L F2 R2
[D, R]
R2 F2 L'
(U)

4) Add the set-up moves F2 L' to complete the algorithm (or just shift the first two moves)

F2 L'
L F2 R2
[D, R]
R2 F2 L'
(U)
L F2

=
F2 L'
L F2 R2
D R D' R'
R2 F2 L'
(U)
L F2

5) Cancel moves and take the inverse to obtain the algorithm.
 
Last edited:
After taking a break and looking at my equivalent to algorithm #1, I realized that I made it much more complicated than it should be. I think we can still learn something from my original explanation, but here is a very simple one:

Algorithm #1:
(Non-symmetrical structure)
L' U R U' L U2 R' U R U2 R' = [L', U R U'] (U) [R U :[R', U] ]

Derivation #2
1) Start with the commutator [U, R']

[U, R']

2) Add set-up moves R U to bring all pieces into the top slice:

R U
[U, R']
U' R'

3) Add a quarter turn, U'.

R U
U R' U' R
U' R'
(U')

4) Add the corner commutator [U R U', L'] to finish off the algorithm:

R U
U R' U' R
U' R'
(U')
[U R U', L']

=
R U
U R' U' R
U' R'
(U')
U R U' L' U R' U' L

5) Cancel moves and take the inverse to achieve the algorithm

I think the other derivations are easy enough to understand without much trouble. This is the one that needed a second approach.

EDIT:
So basically, all 4 algorithms start out with some commutator and eventually work to put all pieces into the same layer to do a quarter turn, and if more work is needed to finish off the rest of the algorithm, then so be it.

This is the exact same idea as many edge "flip" parity algorithms.
 
Last edited:
You mean swapping two dedges and flipping them at the same time ?
Then you can just setup it into a normal PLL parity, like LU'F (PLL parity) F'UL' (for UL and UR dedges) for example.
 
rachmaninovian said:
ah yes. thanks tmoy ^^
Click to expand...

Aha, that case, there is also a commutator, that I prefer (I used to setup to PLL-parity until I found this):

r U2 l D2 l' U2 r' ... does half the job, mirror inverse it on the left for the rest : l U2 r D2 r' U2 l' (do last r' of first half and first l of second together as M)

Rw/Lw instead of r/l and you have OLL 55 + PLL-parity =)
 
Last edited:
rachmaninovian said:
hey cmowla, how many moves can you do a PLL parity + 2 dedge opp edge flip on the 4x4 (uh, to be clear, setup with PLL parity + MU 2 edge flip)?
Click to expand...
TMOY said:
You mean swapping two dedges and flipping them at the same time ?
Click to expand...

I don't know. I probably can't do better than cube explorer:

r F2 U2 r' B2 l B2 r D2 l' E2 B2 l' y2 (13)

, which is equal to what we can already do using "LU'F (PLL parity) F'UL'", assuming that we use a PLL parity algorithm like r2 F2 U2 r2 U2 F2 r2, so that it can be applied to all size cubes. If not, for the 4x4x4, 12 may be the minimum.
 
Originally Posted by rachmaninovian
hey cmowla, how many moves can you do a PLL parity + 2 dedge opp edge flip on the 4x4 (uh, to be clear, setup with PLL parity + MU 2 edge flip)?
Click to expand...

Here are some more algs for your Case#4 at http://rachmaninovian.webs.com/step4b.htm

I don't know of any (without trying to take advantage of the unsolved centers) shorter than this 12 mover -

y (R U' B) [PLL] (B' U R')

but

(R U' R' U) F' [PLL] F (U' R U R')

is fast(er) for me, even though it is a few moves longer.

I also spotted a tweek for [x U M' U M' U2 M U M U] + [2R2 U2 2R2 u2 2R2 u2]

CubeX <Domino> generated 40 (not very useful) 12 movers for 4x4x4 ALWAYS requiring some awkward F/B turns. 3 examples -
R U2 R F2 R' U2 B2 L D2 L' B2 R' (12f*) //order 2
R U2 R F2 L' B2 D2 L F2 R' B2 R' (12f*) //order 2
R U2 L D2 R' F2 U2 R D2 L' B2 R' (12f*) //order 2

At 13/14 Kenneth's - 2R U2 2L D2 2L' U2 (m) U2 2R D2 2R' U2 2L' (13) is probably the best of this type, but the alternating U2/D2 is somewhat undesirable.
 
Last edited:
reThinking the Cube said:
At 13/14 Kenneth's - 2R U2 2L D2 2L' U2 (m) U2 2R D2 2R' U2 2L' (13) is probably the best of this type, but the alternating U2/D2 is somewhat undesirable.
Click to expand...

I'm used to do those D2's because I have them also in the opposite 3-cycles, that are the most common non parity cases if you leave 2 opposite dedges for last. Basicly the same as the 2-flip + PLL commutator, example : Lw' r' D2 r U2 r' D2 r U2 Lw

BTW, com to 2-flip (no parity) : r U2 (r' l') U2 r U2 r' U2 (l r) U2 r' U2
 
You must log in or register to reply here.

Similar threads

DA_BOY
Tips to learn pll algorithms
Replies
2
Views
253
Tabe
Tabe
Michael Wimberly
When to learn Pyraminx L4E
Replies
8
Views
660
Sub 20 Cuber
Sub 20 Cuber
nbwzx
Neural Algorithm Scorer, a deep‑learning model to score Rubik’s cube algorithms
Replies
1
Views
316
abunickabhi
abunickabhi
PhanPhuocan
A new set of algorithms can permute all the last layer edge while inserting the last slot (EPLS)
Replies
14
Views
1,138
Caleb Valenzuela
Caleb Valenzuela
NickMehr
How algorithms created?
Replies
8
Views
1,205
Michael Wimberly
Michael Wimberly
Back
Top