# How important is buffer?



## salamandra (Feb 21, 2021)

How much better is UF than DB DF, or UBL vs UFR? Are there any other buffers that are any good? Why do people think adjacent buffers are good? If I use OP/m2, is it worth switching buffers for 3-style if I don't want to be world class?


----------



## abunickabhi (Feb 21, 2021)

There is no rule that states that adjacent buffers are good, or not. But generally UF/UFR are the best buffers and it happens to be that they are adjacent.
After trying out M2/OP you can try switching buffers a bit and delve into UF/UFR 3-style. You can even try intermediate methods like Eka and Orozco, before learning all the 818 algs of 3-style.

DB is definitely a worse buffer as compared to UF, although UBL and UFR are kinda equal in fingertricks and ergonomics.


----------



## Cuberstache (Feb 21, 2021)

salamandra said:


> How much better is UF than DB, or UBL vs UFR? Are there any other buffers that are any good? Why do people think adjacent buffers are good? If I use OP/m2, is it worth switching buffers for 3-style if I don't want to be world class?


The reason is that UF and UFR have the best algs. I don't know who did it or when but I'm sure someone has tried every buffer and concluded that UF and UFR are the best. The way I look at it, if you're learning an entirely new method already, switching your buffer isn't a big deal at all and you'll get used to it pretty quickly.


----------



## salamandra (Feb 21, 2021)

abunickabhi said:


> DB is definitely a worse buffer as compared to UF, although UBL and UFR are kinda equal in fingertricks and ergonomics.


Sorry, meant DF, not DB


----------



## abunickabhi (Feb 21, 2021)

salamandra said:


> Sorry, meant DF, not DB


DF is also much worse when compared to UF. Many of the algs with UF are S and E slice, which are much faster.


----------



## Habsen (Feb 21, 2021)

Adjacent buffers have an advantage in MBLD because you can deal with edge parity very efficiently even when memoing and executing edges first. The reason is that corner parity algs commonly swap two edge pieces. And one of these edges is commonly the buffer when you have adjacent buffers. So, if you realize that you have parity when memoing edges, i.e. you have an odd number of targets, you can just add the non-buffer edge of the two that are swapped with your corner algs to make it an even number of targets. As a result, the two edges are swapped which will be resolved by the corner parity alg. But an edge parity alg is not needed.


----------



## xyzzy (Feb 21, 2021)

As far as I can tell, there isn't much of a difference between buffers if you're sticking to basic methods, but if you're going to switch to 3-style, you might as well just go for the widely-agreed-to-be-best buffers (UF and URF).

I myself use UF with basic 3-cycles and UFL with OP (with UF-UL swap in memo for parity). Not a typo; it's not the much more common ULB buffer almost everyone else learns for OP. The algs are just slightly nicer for UFL than UBL, methinks—although given how bad I am at 3BLD, saving one second on execution doesn't really matter. Anyhow, here's some wildly uninformed speculation about why adjacent buffers might be better:


Spoiler



(I must emphasise, this is wild speculation. I have not seriously looked into this, and for all I know expert 3BLDers have and got to a different conclusion.)

Whether the buffers are adjacent matters only when there is parity: if there's no parity, then solving the edges and solving the corners are basically independent, so who cares if your buffer choices are adjacent or not.

There are pretty much seven ways of dealing with parity (assuming edge-corner execution order; if you use the other order, then just swap the words "edge" and "corner"):
1. swap buffer edge with last target and swap two other edges, then do the first corner target while swapping those two edges back (as in OP; neither of those two edges is the buffer or last target)
2. 3-cycle the buffer edge with the last target and something else, then do the first corner target while swapping the two unsolved edges back (as in OP; one of those two edges is the buffer)
3. directly solve the edges into a state with two edges swapped (by swapping in memo), then do the first corner target while swapping the two unsolved edges (as in OP)
1'. same as 1, but with the last corner target (solve the earlier corner targets with 3-cycles or whatever first)
2'. same as 2, but with the last corner target
3'. same as 3, but with the last corner target
4. swap buffer edge with last target and swap buffer corner with first target
5. (doing parity at the end) swap buffer edge with last target and swap buffer corner with last target
6. (doing parity at the start) swap buffer edge with first target and swap buffer corner with first target
7. quarter turn premove
7'. quarter turn start

(This does not account for flipped edges, cycle breaks, floating buffer, etc., for which I assume there are _even more_ ways of dealing with parity. Idk, not an expert, don't look at me.)

~ executive summary ~
method 1: prefer non-adjacent buffer (but also prefer method 2 instead)
method 2: prefer adjacent buffer
methods 3, 7: adjacency irrelevant
methods 4, 5, 6: adjacency irrelevant, except to alg learning difficulty, maybe?

As far as I know, nobody seriously does #6 or #7. #1', #2' and #3' are minor variations of #1, #2 and #3 respectively, so I won't treat them differently.

#4, #5 and #6 all require learning a set of 21×22 = 462 parity algs (but presumably a fair chunk of these are easy setups into others). As far as I can tell, whether you use adjacent buffers or not matters little, because most of the algs are weird regardless. However, if you do use adjacent buffers, then it should be easier to find one-move setups between the different parity cases, since that gives you more choices of that one move to use as the setup (e.g. there are 7 choices of layers to turn that fix UF&URF, versus 5 choices that fix UF&ULB), so this might make learning the algs easier.

#1 and #2 are inferior to #3 in that they require an extra alg on average (and 2e2e algs for #1 are slightly worse than 3e algs for #2), but they do have the advantage that you can use the same order for memo and execution (supposedly, this is better for MBLD), whereas the memo-swap used in #3 really only works with ceec order. All three of these need only 21 parity algs, and in the most basic version, you'd just use setups to Y perms.

In #3, whether the buffers are adjacent turns out to be completely irrelevant, since the memo swap works regardless of whether it involves your edge buffer. This leaves only #1 and #2 left to consider.

Also, I say "as in OP", but really, nobody's forcing you to use UB-UR edge swap for OP corners: you could, in theory, use a variant of OP where you swap two other edges. So, which two? Up to AUF, there are only four different choices of edge swaps in the top layer:
- UF-UR (adjacent)
- UF-RU (adjacent flipped)
- UF-UB (opposite)
- UF-BU (opposite flipped)
And there are quite a few more if you include non-top-layer swaps; I know nothing about advanced BLD techniques but I do know a bunch of last layer algs, so let's just suppose I can extrapolate my last layer knowledge and disregard those. And for these swaps, there's still the question of which corner piece is the buffer. By choosing something like UF-UR with URF buffer (so the corner buffer is adjacent to both edges), this maximises the number of free layers, which increases the number of useful 1-move/2-move setups. It also turns out that, at least among the last layer algs I know, UF-UR-URF has nicer algs on average than the others. UF-UB-anything is mostly very bad, for example (think of N perms and F perms); UF-BU-anything seems to be about as bad (possibly worse); UF-UR-UFL shares some cases with UF-UR-URF, but the cases that _aren't_ shared are a bit worse. (I know next to nothing about the UF-RU 22LLs.)

So let's say we're using UF-UR swap with URF buffer. If we're using parity method #1, this means our buffer should be something other than UF or UR, i.e. choosing a buffer that is not adjacent. If we're using parity method #2, this means our buffer should be UF or UR, i.e. one of the edges adjacent to the corner buffer. Since method #2 is better than #1 (uses a 3e alg rather than 2e2e), it follows that one should prefer adjacent buffers.

*However*, all that said, if you use 3-style, whether the buffers are adjacent or not affects only half an alg out of the 10-ish you need to solve the whole cube, which also means that you'll get pretty close to the optimal choice of buffers just by selecting them for having better 3-cycles without caring about parity. In that case, since UF and URF are generally agreed to have the best 3-cycle algs, you should choose those _for that reason_, and not because they're adjacent.


----------



## salamandra (Feb 22, 2021)

Wait wait wait you use UFL for OP? Whats the alg? Wouldn't that be a ton of B moves?


----------

