6
$\begingroup$

I am reasonably competent at using commutators to find my own algorithms on twisty puzzles. Many good tutorials for this exist online.

However, there are also algorithms that are not commutators, because they are odd permutations. These are usually used to solve some kind of parity problem or another. Examples include swapping two corners on a 2x2 Rubik's cube, the "J permutation" on the 3x3, the move that solves the last four edges on a 4x4, and the edge parity move on the 4x4.

I have asked several questions recently about specific examples of these, but each example still feels like a special case and I don't feel I have a deep understanding. For commutators the theory is easy to understand and with a bit of practice I can come up with my own easily, even on a puzzle I haven't seen before, odd permutations it seem much more of a black art and I haven't seen any tutorial or explanation of how to come up with algorithms for them. I am asking for any tips or theory that will allow me to construct my own.

I do know that in general one can often perform a single twist (which on a cube-shaped puzzle is a 4-cycle) and then solve the cube again using commutators, but, for me at least, this tends to result in a long and laborious sequence of moves, rather than a simple algorithm. So I am looking for any theory or techniques by which non-commutator algorithms can be constructed.

Improve this question
$\endgroup$
3
  • 1
    $\begingroup$ Note that d R F' U R' F d' is not an odd permutation of the 4x4 edges. In fact, it is based on the commutator d (R F' U R' F) d' (F' R U F R'), where (R F' U R' F) flips an edge pair in the u/d slice. It is a 3-cycle of edges (assuming d is a move of just the inner slice) - try it out on a solved 4x4x4 and see. Because face turns don't matter yet when you are just pairing up edges, the final 5 face turns can be skipped, in much the same way as you can skip a U turn before/after doing OLL/PLL. $\endgroup$
    – Jaap Scherphuis
    Commented Jun 6, 2018 at 22:46
  • $\begingroup$ @JaapScherphuis thanks, that's very useful information. I had heard it called a parity and assumed it was an odd permutation, but it makes perfect sense that it's a 3-cycle. (Now I also understand why PLL parity on the 4x4 is not really a parity either, since it can be solved with that move.) $\endgroup$
    – N. Virgo
    Commented Jun 8, 2018 at 13:48
  • 1
    $\begingroup$ (I've removed that part from the question. For future readers, the comment thread is about an algorithm for pairing up the last two edge pairs on the 4x4.) $\endgroup$
    – N. Virgo
    Commented Jun 8, 2018 at 13:53

1 Answer 1

Reset to default
3
$\begingroup$

There are three ways to make/find new algorithms.

  1. Commutators/conjugates (i.e. using intuition/knowledge to solve cases)
  2. Computer searches
  3. Trying out random things by hand

I won't talk about the first option since it's seems you're already familiar. For the second, the most commonly used solvers are CubeExplorer and kSolve+. You can input a case, and the program will solve it. Cube explorer is for 3x3 only, but is faster than kSolve+ since kSolve+ was designed to solve more general puzzles and so misses out on some optimisations.

When trying out random things by hand, the approach is usually to do a combination of good moves/sequences and then see what case it solves. This approach doesn't work for finding solutions to specific cases. Instead, you find an algorithm, then check if it's better than known alternatives. This isn't very fast, but can be a fun way to find new algorithms.

As an example: you can try breaking up F2L and re-solving it in other ways. If you take out a pair with R U R', the standard ways to insert it would be R U' R', U R U2 R' or U' R' F R F'. One of these is useless, but the other two produce well-known algorithms. You can get complicated with this too: people have recently started using an OLL which involves taking out a pair with S' R U R' S U' and then re-inserting it with M' U R U' r'.

You can also combine algs you know. Take F R U' R' U' R U R' F'. It's a fast algorithm and leaves OLL unsolved (unsurprising since it's an OLL algorithm itself). You then re-solve OLL by doing R U R' U' R' F R F', and you're left with a Y perm. So, you could use this algorithm to solve Y perms! If you do R U R' U' R' F R F' and then solve OLL, you get a T perm. If you do R U R' U R U2 R' and then solve OLL with U' R' U' R U' R' U2 R, you get a U perm.

You mentioned J perm in your post: this is an example of a "cyclic shift", which is when a conjugate cancels into the algorithm. Notice how if you set up your cube with a J perm by doing R U R' F' R U R' U' R' F R2 U' R' U', we have a 2-edge and 2-corner swap. Track these pieces on the cube as you do R U R' F'. This sets up the pieces to a T perm! So we can do a J perm with [R U R' F': T perm] = [R U R' F': R U R' U' R' F R2 U' R' U' R U R' F'] = [R U R' F' R U R' U' R' F R2 U' R' U' R U R' F' F R U' R'] which cancels into the familiar R U R' F' R U R' U' R' F R2 U' R' U'. See if you can spot why this is called a cyclic shift!

There are countless ways to find new algs, hopefully this gives you a bit of an insight into it. Although usually a computer program is the most efficient way.

Improve this answer
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.