# Pyraminx BLD Method



## SoySauS (Jul 28, 2015)

While the most efficient way to solving Pyraminx blindfolded would be just to 1-look the solve, I'm not good enough at Pyraminx to do that, so I devised this Pyraminx BLD method. 

When you get the puzzle, put it into your orientation by finding the 3 tips that contain your F face color; orient the puzzle so the face shared between them is the F face. 

I memorize in the order Edges > Tips > Centers, and I execute Tips > Centers > Edges, but it doesn't really matter. For algorithms, the center algorithms are just last layer algorithms (last 3 edges around the top center), except for the special ones that rotate 2 centers at once, but those are unnecessary. For the edge algorithms, 4 of them are last 3 edges on the F face algorithms, and the other 4 are last 3 edges around the top center algorithms, so if you can solve a Pyraminx normally you know at least half of them. I'll list all algorithms and how they should be used regardless.

*-------------TIPS-------------*

Memorize in order U L R B, using numbers saying which way it should be twisted.

0 – solved
1 – twist clockwise
2 – twist counterclockwise

So, for example, I might have something like 2012 or whatever, which would mean the twist the U tip ccw, leave the L tip alone, twist the R tip cw, and twist the B tip ccw.

*-------------CENTERS-------------*

Memorize in order U L R B, using numers saying which way it should be twisted.

0 – solved
1 – twist clockwise
2 – twist counterclockwise

*U CW:* R’ U R U R’ U R U

*U CCW:* R’ U’ R U’ R’ U’ R U’

*R CW; L CCW:* R L’ R’ L’ R L R L R L’ R

*L CW; R CCW:* L R’ L’ R’ L R L R L R’ L

Same memorization method as the tips. Really you only need the first 2 algorithms, and you can rotate the puzzle to put that center as the U center (or just replace all the U's with whatever center you're rotating, and all the R's as whatever you want), but the other 2 algorithms are nice when rotating multiple centers. These algorithms obviously preserve edges.

*-------------EDGES-------------*

This is where stuff gets a bit complicated, though not really once you understand. I essentially use FR as my "buffer", and memorize largely the same way as on a 3x3 BLD. I use a unique letter system that I devised to only get good letters, and it works well for me. I'll try to use conventional lettering, however:

The letter system goes around clockwise each face as follows (the buffer [FR] is K): 
Left face: B D F
Front Face: J K L
Right Face: M N P
Down Face: R T Z

*FL > FR > FD:* L R’ L’ R’ U’ R’ U
*FL > FR > DF:* R’ L R L’
*FR > FL > FD:* R’ L R L U L U’
*FR > FL > DF:* L R’ L’ R

*FR > LF > LR:* U’ (L U R U’ R’ L’) U 
*FR > LF > RL:* R’ U’ R U’ R’ U’ R
*LF > FR > LR:* U (R’ U’ L’ U L R) U’
*LF > FR > RL:* R’ U R U R’ U R

*Flipping Alg (FL and FR):* (R’ L R L’) (U L’ U’ L)

Since you can't just swap 2 pieces on the Pyraminx, I solve things in pairs. There are 2 different kinds of pairs; ones that involve FL or LF and ones that don't. First I'll talk about the ones that don't.

*No FL or LF*

For the pairs that don't involve FL or LF, here's how the execution works. I set-up the first letter to FD or DF. I then cycle FL > FR > (FD or DF). I then undo the set-up. This moves the piece from the buffer to where it belongs, moves the next letter in the pair to FL, and moves FL to FR. For the second letter in the pair, I set it up again to FD or DF. I then cycle FR > FL > (FD or DF). I then undo the set-up. This moves the piece from FL to where it belongs, puts the next piece for the next pair into the buffer, and takes the piece that was moved to FR back to FL where it was originally. Sorry if this is kind of confusing, here's a step by step:

For normal cycles (ones that don’t involve FL or LF), do the following:

1.	Set-up the first letter in the pair to either FD or DF. Execute *FL > FR > FD* or *FL > FR > DF*, depending on which one you set-up to. Undo set-up moves.
2.	Set-up the second letter in the pair to either FD or DF. Execute *FR > FL > FD* or *FR > FL > DF*, depending on which one you set-up to. Undo set-up moves.

*Yes FL or LF*

For the pairs that DO involve FL or LF, things are different. I obviously can't use the above method, since FL is part of those cycles. So I just set-up the other letter in the pair and solve the whole pair using 1 algorithm. The algorithms I use depend on if the FL/LF letter is FL or LF. 

FL
If it's FL, I set the other letter up to FD or DF. Depending on which one I set it up to, and depending on if FL is the first letter in the pair or the second, I use one of the 4 original edge algorithms. 

For cycles that involve FL, do the following:

1.	Set the other letter in the pair up to FD or DF. 
2.	If FL is the first letter in the pair, do either *FR > FL > FD* or *FR > FL > DF*, depending on which one you set-up to. Undo set-up moves.
3.	If LF is the second letter in the pair, do either *FL > FR > FD* or *FL > FR > DF*, depending on which one you set-up to. Undo set-up moves. 

LF
If its LF, I set the other letter up to RL or LR. Depending on which one I set it up to, and depending on if LF is the first letter in the pair or the second, I use one of 4 other algorithms.

For cycles that involve LF, do the following:

1.	Set the other letter in the pair up to LR or RL. 
2.	If LF is the first letter in the pair, do either *FR > LF > LR* or *FR > LF > RL*, depending on which one you set-up to. Undo set-up moves.
3.	If LF is the second letter in the pair, do either *LF > FR > LR* or *LF > FR > RL*, depending on which one you set-up to. Undo the set-up moves.

*Flipped Edges*
If the edge is flipped, simply set-up to FL without affecting the buffer piece. For FD and DL, this just involves L moves. For RL, you can use a U move to set-up (it moves the buffer but it still gets everything where you need it). For DR, you can use (R' L'), which also moves the buffer but everything ends up where it should. After executing the *Flipping Alg*, undo the set-up moves.

--------------------------------------------------------------------------------------

Sorry if that was complicated! It's kind of hard to explain it, but it's really not that difficult to do! Below, you can find my original notes (unedited, so they use my wonky letter scheme). Let me know if you have any questions, if any of this could be simplified, it there are any mistakes, etc! Thanks!



Spoiler: Pyraminx BLD Original



*Pyraminx BLD*

*Tips*

Memorize in order U L R B, using numbers saying which way it should be twisted.

0 – solved
1 – twist clockwise
2 – twist counterclockwise

*Centers*

Memorize in order U L R B, using numers saying which way it should be twisted.

0 – solved
1 – twist clockwise
2 – twist counterclockwise

*U CW:* R’ U R U R’ U R U

*U CCW:* R’ U’ R U’ R’ U’ R U’

*R CW; L CCW:* R L’ R’ L’ R L R L R L’ R

*L CW; R CCW:* L R’ L’ R’ L R L R L R’ L

*Edges*

The letter system goes around clockwise each face as follows (the buffer is K): 
Left face: B D F
Front Face: J K L
Right Face: M N P
Down Face: R T Z

*LJ:* L R’ L’ R’ U’ R’ U
*RJ:* R’ L R L’
*JL:* R’ L R L U L U’
*JR:* L R’ L’ R

*DB:* U’ (L U R U’ R’ L’) U 
*DN:* R’ U’ R U’ R’ U’ R
*BD:* U (R’ U’ L’ U L R) U’
*ND:* R’ U R U R’ U R

*Flipping Alg (J/D and K/M):* (R’ L R L’) (U L’ U’ L)


For normal cycles (ones that don’t involve J or D), do the following:

1.	Set-up the first letter in the pair to either L or R. Execute JKL or JKR, depending on which one you set-up to. Undo set-up moves.
2.	Set-up the second letter in the pair to either L or R. Execute KJL or KJR, depending on which one you set-up to. Undo set-up moves.

For cycles that involve J, do the following:

1.	Set the other letter in the pair up to L or R. 
2.	If J is the first letter in the pair, do either KJL or KJR, depending on which one you set-up to. Undo set-up moves.
3.	If J is the second letter in the pair, do either JKL or JKR, depending on which one you set-up to. Undo set-up moves. 

For cycles that involve D, do the following:

1.	Set the other letter in the pair up to B or N. 
2.	If D is the first letter in the pair, do either KDB or KDN, depending on which one you set-up to. Undo set-up moves.
3.	If D is the second letter in the pair, do either DKB or DKN, depending on which one you set-up to. Undo the set-up moves.

For flipped edge pieces, do the following:

1.	Set-up the flipped piece to D/J without moving the buffer piece. If the flipped piece is BN, simply do a U as your set-up. If the flipped piece is PT, use (R’ L’) as your set-up.
2.	Execute the flipping algorithm, and then undo the set-up moves.


----------



## DGCubes (Jul 28, 2015)

This is really cool! I tried a few solves with it and I'm kind of confused, but I'll get the hang of it. Thanks for sharing!


----------



## SoySauS (Jul 28, 2015)

DGCubes said:


> This is really cool! I tried a few solves with it and I'm kind of confused, but I'll get the hang of it. Thanks for sharing!



No problem! Here's an example solve. Scramble in your own orientation. 

Scramble: R L U R L U L' U l b'

*Tips*

Memo: 0201

Execution:

l' b

*Centers*

Memo: 0210

Execution:

Rotate L CCW and R CW: R L’ R’ L’ R L R L R L’ R

*Edges*

Memo: DR-LR FD-DL FL-LD (TB LZ JF)

Execution:

DR - LR

DR: Dw' (R’ L R L’) Dw 
LR: B Dw (L R' L' R) Dw' B'

FD-DL

FD: L R’ L’ R’ U’ R’ U
DL: Dw (L R' L' R) Dw'

FL-LD

Set up LD to FD: Dw
Cycle Buffer to FL to FD: R’ L R L U L U’
Undo set-up: Dw'

Solved!


----------



## BboyArchon (Jul 28, 2015)

I think there's no need to use a method in puzzles than can be solved by 1-looking (2x2, pyraminx, maybe skewb, etc...) It's always nice to have them but they are incredible inefficient compared to 1-look.

I add a video for an example (I'm not an expert, solve starts al 1:13 and it's in spanish). Everything in memo is visual and it was the first time I tried to do it.



Spoiler


----------



## SoySauS (Jul 28, 2015)

BboyArchon said:


> I think there's no need to use a method in puzzles than can be solved by 1-looking (2x2, pyraminx, maybe skewb, etc...) It's always nice to have them but they are incredible inefficient compared to 1-look.
> 
> I add a video for an example (I'm not an expert, solve starts al 1:13 and it's in spanish). Everything in memo is visual and it was the first time I tried to do it.
> 
> ...



Yeah, I mention in the post that I'm not good enough to 1-look Pyraminx and that it would be optimal to just 1-look. This is more theoretical anyway.


----------



## y235 (Jul 28, 2015)

I think this resembles 2BLD, in the sense that even though 1-look is much more efficient, this might be a good practice for 3BLD.


----------



## SoySauS (Jul 28, 2015)

y235 said:


> I think this resembles 2BLD, in the sense that even though 1-look is much more efficient, this might be a good practice for 3BLD.



To be honest most of the execution is completely different, and the cycle-building probably isn't that good of practice. 2x2 at least uses the same method as 3BLD corners.


----------

