In the style of the original post, [R, U] [R', F] [F [R: U']: U']. Only problem is the (F' F) in the middle.
Because commutators are (usually) formed with clearly distinguishable parts that are inverses of each other, and this T-perm alg doesn't have that property, I'd be very keen to believe there's no way to express that T-perm as one commutator.
When you mention writing this as one commutator, do you mean as [x,y](q), were q is a single quarter turn move or can q be a conjugate of a quarter turn? Or were you referring to another structure?
What I'm trying to say (English is not my language) is:
Suppose someone gives you an algorithm, like R U R' U' R' F R2 U' R' U' R U R' F', and tells you to write it in commutator notation. How would you do it?
I know that for example this 3-cycle R U R' D R U' R' D' can be written as [R U R', D], and I also know that the algorithm above (T perm) also can be written with that notation, but I don't know how to "translate" from one notation (standard) to the other (commuator notation). Is there a method? Or you just have to think?
You're English is very good. Just note that we don't start interrogative sentences with ¿ as is done in Spanish.
Anyway, I'm the one who made all of those 2-cycle PLL decompositions on the PLL wiki page. I didn't use a method, exactly. You basically just have to think. I'd say one of the most difficult algorithms to decompose into commutators and conjugates was the N-perm:
[L R: [R', U'] [U2: [U': [L', U] ] [R', U'] ] [U', L'] ] (U')
Since this was such a difficult one, I showed how I did it in the "
Example Decomposition" spoiler in
my forgotten thread where I originally posted all 2-cycle decompositions before I added them to the wiki page (and organized the 2-cycle PLLs to what it is today). (There is no content in that thread besides the example decomposition which is not now in the wiki.)
I know how commutators and conjugates work, I can read commutator notation such as [R', U] [R2: [F', U'] [R, F] ] (U'), but I have some doubts...
¿Can that decomposition be done with any algorithm? ¿Even with an entire solve? If it is possible, ¿how do you do it?
Thanks for your time
Even though I created all of those decompositions (it took me a couple of days to do all of the 2-cycle PLLs in the wiki), I don't find that most are particularly useful in understanding the algorithm. I'm sure some algorithms can be explained like this, as I explained J-Perms using my decompositions
here.
I don't think it's possible to decompose every algorithm into a product of short (4 move) commutators as I did for the 2-cycle PLLs, but clearly we can write any algorithm, scramble algorithm, full solve, etc., using a product of commutators + a single quarter turn if there are an odd number of quarter turns (note however that I'm not referring to the 3x3x3 supercube.).
Below here are single commutators which are equivalent to the building blocks of all sequences (should we break up all sequences into individual quarter face turns, for example).
R U (by Stefan Pochmann)
[R, L R U2 F B' U' D']
R U' (my alg...using Stefan's R U idea)
[R, M' R U' M2 U R' D' F B' E' L E]
M2 (my new alg)
[U' D' S E S U D E', B F E' F2 E' F B']
U2 (by Oscar Roth Andersen)
[L R U2 R' L', U]
U D (my new alg)
[U, F2 R2 B2 S' D2 S]
L' R
[R, y2]
U2 D2
[U2, x2]
.
