Discomantis
Veteran
Ok, so since I'm pretty sure nobody has ever done this, I decided to create some PLL algorithms for 4x4 loopover. These algorithms are from ALL AUF angles. In other words, you don't have to turn the bottom before a PLL, unless the PLL algorithm requires you to do so.
Also, these algorithms are assuming you already solved the L piece. If you do some sort of keyhole thing with L, then these algorithms won't cover all the cases.
Notation: Outer moves are same as 3x3, inner moves are same as 3x3 but lower case letters.
Here are all of the algorithms in alphabetical order:
Algorithm: R' D2 R D R' D R D
What the PLL looks like: MNPO
Group: 2 solved
Algorithm: R' D' R D' R' D2 R D'
What the PLL looks like: MONP
Group: 2 Solved
Algorithm: R' D2 R D' R' D' R
What the PLL looks like: MOPN
Group: Only M solved
Algorithm: R' D R D R' D2 R
What the PLL looks like: MPNO
Group: Only M solved
Algorithm: R' D' R D R' D R D R' D' R
What the PLL looks like: MPON
Group: 2 solved
Algorithm: R' D' R D2 R' D' R D'
What the PLL looks like: NMOP
Group: 2 solved
Algorithm: R' D R D' R' D' R D' R' D R D What the PLL looks like: NMPO
Group: None solved
Algorithm: D
What the PLL looks like: NOPM
Group: Last layer skip
Algorithm: r' D2 r D' r' D' r
What the PLL looks like: NOMP
Group: Only P solved
Algorithm: D' R' D2 R D R' D R
What the PLL looks like: NPMO
Group: None solved
Algorithm: R' D' R D' R' D2 R
What the PLL looks like: NPOM
Group: Only O solved
Algorithm: r' D r D r' D2 r
What the PLL looks like: OMNP
Group: Only P solved
Algorithm: R' D R D2 R' D R D'
What the PLL looks like: OMPN
Group: None solved
Algorithm: r' D' r D r' D r D r' D' r
What the PLL looks like: ONMP
Group: 2 solved
Algorithm: R' D' R D2 R' D' R
What the PLL looks like: ONPM
Group: Only N solved
Algorithm: D2
What the PLL looks like: OPMN
Group: Last layer skip
Algorithm: R' D2 R D R' D R D'
What the PLL looks like: OPNM
Group: None solved
Algorithm: D'
What the PLL looks like: PMNO
Group: Last layer skip
Algorithm: R' D2 R D R' D R
What the PLL looks like: PMON
Group: Only O solved
Algorithm: R' D R D2 R' D R
What the PLL looks like: PNMO
Group: Only N solved
Algorithm: R' D2 R D' R' D' R D'
What the PLL looks like: PNOM
Group: Only N solved
Algorithm: R' D' R D2 R' D' R D
What the PLL looks like: POMN
Group: None solved
Algorithm: R' D R D' R' D2 R D R' D' R
What the PLL looks like: PONM
Group: None solved
Now, I'm not sure how worth it is to use PLL's from all angles. It might be better to solve the M piece before doing a PLL algorithm. as it would yield faster singles in case you get a last layer skip, and would make recognition easier as you only have to recognize 2 pieces once you solve M, and not 3. Plus, 23 algorithms is a lot to learn, and it is more cases than 3x3 PLL.
Also, these algorithms are assuming you already solved the L piece. If you do some sort of keyhole thing with L, then these algorithms won't cover all the cases.
Notation: Outer moves are same as 3x3, inner moves are same as 3x3 but lower case letters.
Here are all of the algorithms in alphabetical order:
Algorithm: R' D2 R D R' D R D
What the PLL looks like: MNPO
Group: 2 solved
Algorithm: R' D' R D' R' D2 R D'
What the PLL looks like: MONP
Group: 2 Solved
Algorithm: R' D2 R D' R' D' R
What the PLL looks like: MOPN
Group: Only M solved
Algorithm: R' D R D R' D2 R
What the PLL looks like: MPNO
Group: Only M solved
Algorithm: R' D' R D R' D R D R' D' R
What the PLL looks like: MPON
Group: 2 solved
Algorithm: R' D' R D2 R' D' R D'
What the PLL looks like: NMOP
Group: 2 solved
Algorithm: R' D R D' R' D' R D' R' D R D What the PLL looks like: NMPO
Group: None solved
Algorithm: D
What the PLL looks like: NOPM
Group: Last layer skip
Algorithm: r' D2 r D' r' D' r
What the PLL looks like: NOMP
Group: Only P solved
Algorithm: D' R' D2 R D R' D R
What the PLL looks like: NPMO
Group: None solved
Algorithm: R' D' R D' R' D2 R
What the PLL looks like: NPOM
Group: Only O solved
Algorithm: r' D r D r' D2 r
What the PLL looks like: OMNP
Group: Only P solved
Algorithm: R' D R D2 R' D R D'
What the PLL looks like: OMPN
Group: None solved
Algorithm: r' D' r D r' D r D r' D' r
What the PLL looks like: ONMP
Group: 2 solved
Algorithm: R' D' R D2 R' D' R
What the PLL looks like: ONPM
Group: Only N solved
Algorithm: D2
What the PLL looks like: OPMN
Group: Last layer skip
Algorithm: R' D2 R D R' D R D'
What the PLL looks like: OPNM
Group: None solved
Algorithm: D'
What the PLL looks like: PMNO
Group: Last layer skip
Algorithm: R' D2 R D R' D R
What the PLL looks like: PMON
Group: Only O solved
Algorithm: R' D R D2 R' D R
What the PLL looks like: PNMO
Group: Only N solved
Algorithm: R' D2 R D' R' D' R D'
What the PLL looks like: PNOM
Group: Only N solved
Algorithm: R' D' R D2 R' D' R D
What the PLL looks like: POMN
Group: None solved
Algorithm: R' D R D' R' D2 R D R' D' R
What the PLL looks like: PONM
Group: None solved
Now, I'm not sure how worth it is to use PLL's from all angles. It might be better to solve the M piece before doing a PLL algorithm. as it would yield faster singles in case you get a last layer skip, and would make recognition easier as you only have to recognize 2 pieces once you solve M, and not 3. Plus, 23 algorithms is a lot to learn, and it is more cases than 3x3 PLL.
Last edited:
