Void Swap: A Unique Beginner 3BLD Method

[trangium]

Motivation:
The most commonly taught beginner 3BLD method, Old Pochmann, has a significant problem for edges: Setups are long and unergonomic, making it hard for beginner blinders to correctly undo their setup moves and execute setups quickly. Fortunately, there's a variation that's just as simple as Old Pochmann: Void Swap. The edges algorithm swaps 2 edges and cycles 4 centers, which leads to much less restricted setups.

The Method:
Speffz lettering will be used here.
Edges Buffer: H
Edges Target: B
Allowed setups: <U, R, F, D>
Edge swap alg: R' F2 R2 E' R' S' R' F2 R S (Use right index for E', and left index push for S)
Parity: Add W to the end of edge memo
Special case: if there are an odd number of edge letter pairs (include the letter you added for parity), add M' S' M2 S M to the start of execution

Corner Buffer: H
Corner Target: C
Allowed setups: <U, R, F>
Corner swap alg: R B R' U2 r U' r B r2 U2

Example solve:
View at alg.cubing.net

Comparison with other BLD methods (for edges):

Method	Average Edge Swap Length	Average Setup+Restore Length (taking cancellations into account)	Average Moves Per Edge
Basic OP	14	4	18
OP with Ja/Jb for tricky cases	13	2	15
Void Swap	10	2.3	12.3
M2	1	5.7	6.7
3-style	N/A	N/A	~4

Conclusion:
Overall, I think Void Swap is better than Old Pochmann but worse than M2. It's a good starting option for those who are comfortable with S/E slices, and don't want to immediately deal with the increased mental overhead of M2's setups and special cases.

 

[Blobinati Cuber]

Looks very interesting!! Don’t you mean M2 E M2 E’ for parity, to swap the E layer centers?
And why are you only allowed to do UFRD turns for the edges? If the alg is cycling centers, then surely you wouldn’t have to worry about anything else right?

 

[V Achyuthan]

Motivation:
The most commonly taught beginner 3BLD method, Old Pochmann, has a significant problem for edges: Setups are long and unergonomic, making it hard for beginner blinders to correctly undo their setup moves and execute setups quickly. Fortunately, there's a variation that's just as simple as Old Pochmann: Void Swap. The edges algorithm swaps 2 edges and cycles 4 centers, which leads to much less restricted setups.

The Method:
Speffz lettering will be used here.
Edges Buffer: H
Edges Target: B
Allowed setups: <U, R, F, D>
Edge swap alg: R' F2 R2 E' R' S' R' F2 R S (Use right index for E', and left index push for S)
Parity: Add W to the end of edge memo
Special case: if there are an odd number of edge letter pairs (include the letter you added for parity), add E2 M’ E2 M to the start of execution

Corner Buffer: H
Corner Target: C
Allowed setups: <U, R, F>
Corner swap alg: R B R' U2 r U' r B r2 U2

Example solve:
View at alg.cubing.net

Comparison with other BLD methods (for edges):

Method	Average Edge Swap Length	Average Setup+Restore Length (taking cancellations into account)	Average Moves Per Edge
Basic OP	14	4	18
OP with Ja/Jb for tricky cases	13	2	15
Void Swap	10	2.3	12.3
M2	1	5.7	6.7
3-style	N/A	N/A	~4

Example Solve:


Conclusion:
Overall, I think Void Swap is better than Old Pochmann but worse than M2. It's a good starting option for those who are comfortable with S/E slices, and don't want to immediately deal with the increased mental overhead of M2's setups and special cases.

This looks cool. I might try this

 

[CubeRed]

Nice job. This might actually be the thing that gets me into 3BLD.

 

[Cuberstache]

Looks very interesting!! Don’t you mean M2 E M2 E’ for parity, to swap the E layer centers?
And why are you only allowed to do UFRD turns for the edges? If the alg is cycling centers, then surely you wouldn’t have to worry about anything else right?

L and B moves move the buffer piece

 

[trangium]

Looks very interesting!! Don’t you mean M2 E M2 E’ for parity, to swap the E layer centers?
And why are you only allowed to do UFRD turns for the edges? If the alg is cycling centers, then surely you wouldn’t have to worry about anything else right?

M2 E M2 E' and M' S' M2 S M' both have the same effect. I personally prefer the first one. As Cuberstache pointed out, the buffer is LB, and you can't move the buffer, thus <U, R, F, D> are the allowed setups.

 

[Lucas Garron]

Hmm, that's a neat! But using a 4-cycle requires keeping track of state seems unnecessary extra work.

What about using a an order-2 center parity?

Something like: U' M' U M U M' u M u' M U' M' U M' U'
Or maybe something like: M u M' u' M2' u' M' u2' M' u' M u2' M u' M u'

(Of course, you'd also want something for corners with the same center parity. I found F U' R u2 F u2 M2 U F' U r' U2 F r u U R', but that doesn't quite seem to cut it.)

 

[trangium]

Hmm, that's a neat! But using a 4-cycle requires keeping track of state seems unnecessary extra work.

What about using a an order-2 center parity?

Something like: U' M' U M U M' u M u' M U' M' U M' U'
Or maybe something like: M u M' u' M2' u' M' u2' M' u' M u2' M u' M u'

(Of course, you'd also want something for corners with the same center parity. I found F U' R u2 F u2 M2 U F' U r' U2 F r u U R', but that doesn't quite seem to cut it.)

I actually considered that. The best algs I found for that were M' u' M' u M' u M' u2 M' u M' u M' u' and R' F2 R2 E' M' R' S' r' F2 R S, which are significantly worse than the 4-cycle alg. A better approach would be to alternate between R' F2 R2 E' R' S' R' F2 R S and R E R2' F2 R S' R' F2 R S which cycle the centers in opposite directions. Personally, I prefer the way that I mentioned in the original post, but different variants may work well for different people.

EDIT: There's also S' r' F2 R S R' F2 R2 E' (M' R') which is not too bad.

 

[Cuberstache]

M2 E M2 E' and M' S' M2 S M' both have the same effect.

I believe @Blobinati Cuber was referring to the typo in the OP:

Special case: if there are an odd number of edge letter pairs (include the letter you added for parity), add E2 M’ E2 M to the start of execution

 

[abunickabhi]

Motivation:
The most commonly taught beginner 3BLD method, Old Pochmann, has a significant problem for edges: Setups are long and unergonomic, making it hard for beginner blinders to correctly undo their setup moves and execute setups quickly. Fortunately, there's a variation that's just as simple as Old Pochmann: Void Swap. The edges algorithm swaps 2 edges and cycles 4 centers, which leads to much less restricted setups.

The Method:
Speffz lettering will be used here.
Edges Buffer: H
Edges Target: B
Allowed setups: <U, R, F, D>
Edge swap alg: R' F2 R2 E' R' S' R' F2 R S (Use right index for E', and left index push for S)
Parity: Add W to the end of edge memo
Special case: if there are an odd number of edge letter pairs (include the letter you added for parity), add M' S' M2 S M to the start of execution

Corner Buffer: H
Corner Target: C
Allowed setups: <U, R, F>
Corner swap alg: R B R' U2 r U' r B r2 U2

Example solve:
View at alg.cubing.net

Comparison with other BLD methods (for edges):

Method	Average Edge Swap Length	Average Setup+Restore Length (taking cancellations into account)	Average Moves Per Edge
Basic OP	14	4	18
OP with Ja/Jb for tricky cases	13	2	15
Void Swap	10	2.3	12.3
M2	1	5.7	6.7
3-style	N/A	N/A	~4

Conclusion:
Overall, I think Void Swap is better than Old Pochmann but worse than M2. It's a good starting option for those who are comfortable with S/E slices, and don't want to immediately deal with the increased mental overhead of M2's setups and special cases.

Have you considered BOP method as well?

I think BOP also have weird setup moves. But it is a bit better than classic Old Pochmann method.

 

[trangium]

Have you considered BOP method as well?

I think BOP also have weird setup moves. But it is a bit better than classic Old Pochmann method.

BOP and Void Swap have different objectives. To quote the proposer of BOP:

The idea was basically if one wants to learn to BLD solve and that's it, OP is fine.

If one wants to BLD solve and know they will want to get fast and work for it eventually, being a speedcuber, I am proposing that BOP is the better way to go.

If one doesn't mind putting in the work and knows that they will want to push BLD to higher levels, I'd start with Orozco for corners/edges and break into intuitive 3-style as fast as possible.

That's a personal preference. I know some may advise differently.

Essentially, if one wants to take BLD seriously enough that they intend to eventually use 3-style, they should use BOP. But if one just wants to learn how to solve it blindfolded as soon as possible, they should use Void Swap.

 

[GodCubing]

Void Swap 2.0:

Corners:
alg: R' F R2 U' R' U' R U R' F' R U R' U'
buffer: E
target: V

Edges:
alg: R' F2 R2 E' R' S' R' F2 R S (alt: S' R' F2 R S R' F2 R2 E' R')
buffer: R
target: B

Parity:
alg: U R' D' F R F' U' R' D R2 B' R'

Special Case: Odd number of edge letter pairs
alg: M' S M2 S M'

 

[Lucas Garron]

I gave this another go with https://experiments.cubing.net/cubing.js/twsearch/text-ui.html and found an edge swap I kinda like:

• Symmetric across M.
• Swaps DF and UB, matching the M2 method.
• Only M', M2', u', and u2', to minimize regrips. (Can also be mirrored and inverted to preferred M and u directions.)
• Can also be mirrored to DB and UF, or adapted by changing the last move to M, which can also cancel with setup. (In fact, I actually slightly prefer it that way.)
• It has two halves that differ only in the last move!

 Twizzle link 

 Title 

Lucas's M2 Void Swap (order 2)

 Moves 

u' M' u2' M' u2' M' u' M2'
u' M' u2' M' u2' M' u' M'

I haven't fount a great corner swap yet, but I can kind of fingertrick these:

• R2 F2' U' r' R' u R2 F2' u r' R' U' r R F2 U' // ULF ↔ UFR
• u M U' M u M' r F' r2' U' F U F r2 F r' u2' // DRF ↔ URB (classic R2)

 

[GodCubing]

I gave this another go with https://experiments.cubing.net/cubing.js/twsearch/text-ui.html and found an edge swap I kinda like:

• Symmetric across M.
• Swaps DF and UB, matching the M2 method.
• Only M', M2', u', and u2', to minimize regrips. (Can also be mirrored and inverted to preferred M and u directions.)
• Can also be mirrored to DB and UF, or adapted by changing the last move to M, which can also cancel with setup.
• It has two halves that differ only in the last move!

 Twizzle link 

 Title 

Lucas's M2 Void Swap (order 2)

 Moves 

u' M' u2' M' u2' M' u' M2'
u' M' u2' M' u2' M' u' M'

I haven't fount a great corner swap yet, but I can kind of fingertrick these:

• R2 F2' U' r' R' u R2 F2' u r' R' U' r R F2 U' // ULF ↔ UFR
• u M U' M u M' r F' r2' U' F U F r2 F r' u2' // DRF ↔ URB (classic R2)

wow, that looks great. would the standard yperm based alg work? because then you could just add a letter to memo for parity

 

[trangium]

wow, that looks great. would the standard yperm based alg work? because then you could just add a letter to memo for parity

If you want to use the standard y-perm based alg, you need a UB-UL swap for parity. So, if UB is your buffer, then adding the letter D would work.

 

[bcube]

As a consequence of returning to blindsolving after 20 years, I am looking for the best beginner method for me.

I discarded a 1-algorithm method because of difficult/long setup moves, so I am deciding between the Classic Pochmann (using only T-permutation for edges, T+U permutations for parity, Y-permutation for corners) and this Void Swap.

The biggest issue for me with Void Swap is the 4-cycle of centers. In case of order 2 swap, I don´t like "weird" move set (for me). So I am wondering if there is a shorter algorithm (say, maximum of 15 movves) for the following case using the move set <M, U, E>? It doesn´t necessarily have to be this case though, I am looking for any order 2 swap using <M, U, E> in at most 15 moves.



I tried Cube Explorer for generetaing an algorithm for this case using <M, U, E> but it took too long on my machine without finding one.

 

[abunickabhi]

As a consequence of returning to blindsolving after 20 years, I am looking for the best beginner method for me.

I discarded a 1-algorithm method because of difficult/long setup moves, so I am deciding between the Classic Pochmann (using only T-permutation for edges, T+U permutations for parity, Y-permutation for corners) and this Void Swap.

The biggest issue for me with Void Swap is the 4-cycle of centers. In case of order 2 swap, I don´t like "weird" move set (for me). So I am wondering if there is a shorter algorithm (say, maximum of 15 movves) for the following case using the move set <M, U, E>? It doesn´t necessarily have to be this case though, I am looking for any order 2 swap using <M, U, E> in at most 15 moves.



I tried Cube Explorer for generetaing an algorithm for this case using <M, U, E> but it took too long on my machine without finding one.

Interesting concept,

20 years is a long period!

 

[bcube]

Hmm, that's a neat! But using a 4-cycle requires keeping track of state seems unnecessary extra work.

What about using a an order-2 center parity?

Something like: U' M' U M U M' u M u' M U' M' U M' U'
Or maybe something like: M u M' u' M2' u' M' u2' M' u' M u2' M u' M u'

(Of course, you'd also want something for corners with the same center parity. I found F U' R u2 F u2 M2 U F' U r' U2 F r u U R', but that doesn't quite seem to cut it.)

Well, if the objective of the method is keeping everything as simple as possible, I know I would not learn another algorithm just for that - it seems like an unnecessary extra work for me. That is an advantage of Void Swap in comparison with Classic Pochmann - as myself not being a CFOP user, I would have to learn 3 new algorithms for Classic Pochmann (edges, corners, parity), while I would need to learn only 2 new algorithms for Void Swap with order-2 swap (edges, corners).

 

[bcube]

20 years is a long period!

Perharps I did not make myself clear - what I meant is that I learned how to solve the cube blindfolded 20 years ago but haven´t solved it blindfolded since then (as opposed to myself trying to solve the cube blindfolded after next 20 years from now). Nevermind if you understood what I meant at first sight .

 

[Lucas Garron]

The biggest issue for me with Void Swap is the 4-cycle of centers. In case of order 2 swap, I don´t like "weird" move set (for me). So I am wondering if there is a shorter algorithm (say, maximum of 15 movves) for the following case using the move set <M, U, E>? It doesn´t necessarily have to be this case though, I am looking for any order 2 swap using <M, U, E> in at most 15 moves.



I tried Cube Explorer for generetaing an algorithm for this case using <M, U, E> but it took too long on my machine without finding one.

My working alg for this case is:

 Twizzle link 

M' u'
M' u M' u
M' u2'
M' u M' u
M' u'

It's very nice to remember and execute.

I've been trying to find a good compatible corner alg for over two years, but haven't found a nice one yet.