# Permutation groups

#### cmhardw

Hello everyone,

I've been thinking recently about what it means, in the general sense, to read an algorithm backwards, and if this can even be generalized on the Rubik's cube.

For palindrome algorithms, obviously you have the same effect if you read forwards or backwards.
example: M2 U M2 U2 M2 U M2

For algs that don't contain either one of a pair of parallel faces, reading that algorithm backwards is simply the inverse of the reflection about the plane parallel to both of those planes.

example: R' U R' U' R' U' R' U R U R2

This algorithm contains no F or B turns, so reading it backwards is simply the inverse of the reflection of this alg in the FB plane.

Another example of this same case is the A perm.

A perm: R' F R' B2 R F' R' B2 R2

This algorithm contains no U or D turns, so reading it backwards functions as the inverse of the reflection of this algorithm in the UD plane.

Now an interesting one is the T permutation. This algorithm contains sides in each of the 3 axes of the cube. Also, this algorithm is not a palindrome.

R U R' U' R' F R2 U' R' U' R U R' F'

reading this algorithm backwards seemingly scrambles the U,F and R faces.

What I wanted to do with this was to test to what extent this new algorithm (reading the T perm backwards) is not commutative with the actual T perm. So I'm going to do the commutator:

(T perm) (read the T perm backwards) (T perm) ' (read the T perm backwards) '

which is
(R U R' U' R' F R2 U' R' U' R U R' F') (F' R' U R U' R' U' R2 F R' U' R' U R) (F R U' R' U R U R2 F' R U R U' R') (R' U' R U R F' R2 U R U R' U' R F)

This leaves the cube semi-scrambled, and the net effect (as a permutation) is:
Corners: (UBR <-> UFR) (UFL <-> FLD)
Edges: (UL->UF->UR->UL)

Cube explorer generates the same permutation with: U' L2 U2 L2 R U' L2 U R' U2 L2 U'

Now I have 2 questions. How can I interpret/analyze this overall net permutation to see the extent to which the T perm and the (T perm read backwards) are not commutative?

My second question is: is there a general meaning to the permutation generated by reading a given permutation backwards? I expect that this will have to be broken down into sub-cases. I have listed above 2 sub-cases for which the permutation generated by reading backwards is either the equivalent permutation to the original, or is the inverse of the reflection in the plane of sides missing from the alg.

I find this idea fascinating, but I don't know where to start to study it more, or even what question I probably should be asking.

--edit--
Here are 2 actually useful algorithms created using the above procedure.

Let my algorithm be X = R U' R'

I will now create the commutator X (read X backwards) X' (read X backwards)' which is:
(R U' R') (R' U' R) (R U R') (R' U R) or R U' R2 U' R2 U R2 U R

which sets up a very interesting F2L trick, in my opinion. Do the inverse of the final algorithm to solve: R' U' R2 U' R2 U R2 U R'

I might actually try to learn to recognize that case, even though it wouldn't come up often.

Another useful one is to let the algorithm X = M2 U
Then (X) (read X backwards) X' (read X backwards)' = (M2 U) (U M2) (U' M2) (M2 U') = M2 U2 M2 U2
which is a recognizable pattern.

I'm getting the feeling that this process may be useful for creating F2L algorithms and/or patterns. I'll have to look into this more.
--edit--

--edit #2--
Here's a nice fast BLD edge 3-cycle using the above process

Let X = (R U' R' U) and do X (read X backwards) X' (read X backwards)' to get: R U' R' U2 R' U' R U' R U R2 U R U'
--edit #2--

Chris

Last edited:

#### AvGalen

I will look into this Chris. I am fascinated and think it will help me understand premoves (for FMC) even better.

But don't expect to much of this. Many algs that have a limited effect on the cube (like R U' R') will give "alg-like-results" when inverted/mirrored/reversed or slightly manipulated.

Just yesterday I realized that the 7 move Niklas (at least I think that's what it's called) is actually a 10 move commutator that I used 20 years ago for permuting corners (LL was OE, PE, PC, OC):
(URU'R') L' (R U R' U') L cancels to
U R U' L' U R' U' L and for speedcubing the first U can be skipped because all affected pieces are in the U layer

#### JBCM627

##### Member
Just yesterday I realized that the 7 move Niklas (at least I think that's what it's called) is actually a 10 move commutator that I used 20 years ago for permuting corners (LL was OE, PE, PC, OC):
(URU'R') L' (R U R' U') L cancels to
U R U' L' U R' U' L and for speedcubing the first U can be skipped because all affected pieces are in the U layer
Likewise with the A perm, a while ago. I don't know much about commutors, but I think this falls in that category. While learning a "removable corner" method, compeltely intuitive and requiring no memorized algs to solve the cube, I realized a few things.

Let X = (R' D2 R) = X', and try something like X U X' U'. Notice how it cycles 3 corners.

So for the A alg, let S = (R' U) = setup moves, and so S' = (U' R), and do:
S X U' X' U S'

This easily leads to other versions of the A alg, such as a useful BLD alg I found, where S = (U Rw') and X = (L D2 L'):
S U' X U X' S'

If you know how this works, it is very easy to do in reverse, mirror it, invert, etc, without needing to write anything down... its the A alg, intuitively. I think performing an alg efficiently in reverse, and knowing what it will do, may require an understanding such as this.

So if you look at the A alg in reverse now, it should be fairly self explanatory why it ends up as an inverted reflection: look at what happens to the X and S when you mirror them.

If you have an unfamiliar algorithm and are unsure how it works, perhaps this is not easy to determine, although your observation about not using opposite faces is very good. Perhaps it is easy to decompose all algs that do not use faces on the same axis like this?

#### AvGalen

...
Here are 2 actually useful algorithms created using the above procedure.
...R U' R2 U' R2 U R2 U R....to solve: R' U' R2 U' R2 U R2 U R'

I might actually try to learn to recognize that case, even though it wouldn't come up often.
--edit #2--
Here's a nice fast BLD edge 3-cycle using the above process

Let X = (R U' R' U) and do X (read X backwards) X' (read X backwards)' to get: R U' R' U2 R' U' R U' R U R2 U R U'
Chris
I didn't really make time to dive into this subject because I am basically convinced now that not much will come out of this. I just analysed the algs you found and wanted to let you know they can be done much better (shorter and faster)

For R U' R2 U' R2 U R2 U R I would use D' R2 D y R2 U' R2 (keyhole + FMC combination), but I guess (U' R2 U') (R2 U R2) would be faster to perform.

And R U' R' U2 R' U' R U' R U R2 U R U' can be solved (within a second) with (R'U'R'U'R')(URURU)

Let X = (R' D2 R) = X', and try something like X U X' U'. Notice how it cycles 3 corners.

So for the A alg, let S = (R' U) = setup moves, and so S' = (U' R), and do:
S X U' X' U S'
So the A-Perm is actually:
(R' U) (R' D2 R) U' (R' D2 R) U (U' R) which becomes
(R' U) (R' D2 R) U' (R' D2 R2)
so "easy" #### JBCM627

##### Member
Let X = (R' D2 R) = X', and try something like X U X' U'. Notice how it cycles 3 corners.

So for the A alg, let S = (R' U) = setup moves, and so S' = (U' R), and do:
S X U' X' U S'
So the A-Perm is actually:
(R' U) (R' D2 R) U' (R' D2 R) U (U' R) which becomes
(R' U) (R' D2 R) U' (R' D2 R2)
so "easy" Right There are nice cancelations there. And naturally, if you rotate this, it becomes R' F R' B2 R F' R' B2 R2, which is the algorithm chris posted.

--
Edit: The BLD alg I mentioned simplifies to:
U Rw' U' L D2 L' U L D2 x U'
...I looked for a few other ones like this, but couldn't find any that both triggerd well and preserved orientation of corners. Nothing too simple with an intuitive explanation to do (UFL -> UBR -> DRF), that I could find... aside from Tyson's alg...
--

I can see how knowing some of this this would be nice in some respect, as you can generate (some) new algs on the spot in competition... it would certainly be possible, but also probably difficult. It would certainly require a lot of practice to become useful in competition at all...

Last edited:

#### cmhardw

I can see how knowing some of this this would be nice in some respect, as you can generate (some) new algs on the spot in competition... it would certainly be possible, but also probably difficult. It would certainly require a lot of practice to become useful in competition at all...
To be clear though, although I am a bit interested in the utility of using this procedure to create algs, my main interest is in trying to see if reading an algorithm backward has an understood meaning from a group theory sense for the Rubik's cube in general. If this is not true in general I am interested in all special sub-cases where it is meaningful. The only two meaningful special sub-cases that I personally know of are palindrome algs, which are equivalent when read forward or backward, and algs that do not contain either turn in one of the 3 axes groups (LR group, FB group, UD group). This last case is the one where reading backwards is the inverse of the reflection about the plane of the group of missing faces (i.e. if your alg does not contain U or D turns, and you read it backwards, then you are executing the inverse of the reflection of the algorithm in the UD plane). Does anyone know of any others?

Chris

#### cuBerBruce

##### Member
My second question is: is there a general meaning to the permutation generated by reading a given permutation backwards?
I first point out that you mean reading an "algorithm" backwards, not a permutation. A "permutation" is an effect that an algorithm has on the cube. Many different algorithms can have the same effect. The T perm Chris mentions (R U R' U' R' F R2 U' R' U' R U R' F') has the same effect as (R2 U' R2 U R2 B2 U B2 D' R2 D) or (R2 U' R2 U R2 y R2 U R2 u' R2 D). (The 2nd alg above is merely the 3rd alg converted into <U,D,L,R,F,B>.) These algs are all the give the same permutation, but doing them in reverse order has three different resulting effects. Actually the last one is somewhat interesting in that when read backwards has the same effect as it does forward.

The effect of the inverse of the FB-reflection (or UD- or LR-reflection) can be described using group theory.

First, let m_F be represent the operation of reflecting the cube with respect to FB. Performing an FB-reflection of an alg is represented by conjugating the alg by m_F. Since m_F is its own inverse, we can simply write this conjugation as m_F alg m_F. Similarly we can define m_L and m_U as LR- and UD-reflection operations.

We can create a truth table for these conjugations for basic cube moves as given below. Inverses of the cube moves are also shown for reference.

Code:
Truth table

g     g'    m_F g m_F   m_L g m_L   m_U g m_U
-     --    ---------   ---------   ---------
U     U'        U'          U'          D'
U'    U         U           U           D
U2    U2        U2          U2          D2
D     D'        D'          D'          U'
D'    D         D           D           U
D2    D2        D2          D2          U2
L     L'        L'          R'          L'
L'    L         L           R           L'
L2    L2        L2          R2          L2
R     R'        R'          L'          R'
R'    R         R           L           R'
R2    R2        R2          L2          R2
F     F'        B'          F'          F'
F'    F         B           F'          F'
F2    F2        B2          F2          F2
B     B'        F'          B'          B'
B'    B         F           B           B
B2    B2        F2          B2          B2
Let s be a sequence of Rubik's cube moves.
When we take the inverse of the FB-reflection for a sequence s, we can express that as:
(m_F s m_F)'

First we apply m_F s m_F. We can reflect the sequence s by reflecting the elements of s individually. (For example, let's say we're evaluating m_F a b m_F. We can write m_F = m_F a (m_F m_F) b m_F since (m_F m_F) is the identity. Then we use associativity to get (m_F a m_F) (m_F b m_F). So by extending this to longer sequences, the reflection of the alg can be peformed element by element.) So if S = R' U R' U' R' U' R' U R U R2, then m_F s m_F is R U' R U R U R U' R' U' R2 applying the truth table. Now take the inverse of that, you get:
R2 U R U R' U' R' U' R' U R. (I take it as elementary that the inverse of an alg can be obtained by applying the alg in reverse order, using the inverse of each element.) Basically as long as the elements in the sequence s satisfy p' = m_F p m_F (for each and every p that is an element of s), then the inverse of the FB-reflection of the alg is simply the alg backwards. The reflection is applying the inverse of each move (under the conditions stated) and applying the inverse undoes that effect while also reversing the order. So the net effect is you end up with the alg backwards.

So the group theory shows how the applying the inverse of the FB-reflection of an alg, you simply get the alg backwards (if certain moves are avoided).

I think trying to get further generalizations runs into problems because of the fact that the reversing of an alg is an operation on the "alg" itself and not the group element, as I illustrated earlier. The notion of reversing the alg is even affected by using associativity in expressing an alg.

Let's say g, a, b, and c are elements of the Rubik's cube group ( <U,D,L,R,F,B> ) and g = abc.
From associative we can write: g = (ab)c = a(bc).
Now let p = ab and q = bc.
So we have g = pc = aq.
Now what is g backwards? Is it cba? Is it cp = cab? Or is it qa = bca?

Simply grouping moves together differently changes the meaning of what it means to "read the alg backwards." So that's one reason I think why group theory is not going to provide much further generalizing of what "reading an alg backwards" does.

Last edited: