garron.us >
Cube >
BLD > r2
General r2 for BLD
Lucas Garron; February 10-24, 2008
•
Edges/Midges •
Wings •
X-Centers •
T-Centers •
"Oblique" Centers •
•
Directions •
Notation •
Labeling •
Supercubes •
Algorithms •
Be free •
Parity •
Notes •
In June 2007, Stefan Pochmann published a fantastic method for 3x3x3 BLD:
M2R2. R2 turns out to be a bit cumbersome because half the pieces in the orbit are located in the buffer slice.
M2, however, is a brilliant EP method, and Erik soon
applied it to 4x4x4 edges (which is actually how Pochmann developed M2), using the r slice (why r and not l? most cubers twist more with the right hand and hold the cube with the left, so r2 is easier/faster).
However, it somewhat languished there. I figured out an ugly way to do r2 for x-centers, by bringing the center to Ful, and gave up because it was too inefficient.
Then, I tried to find better ways to shoot to Ubr, and eventually developed the following algorithms, which work well for any piece type (except corners) on a cube of any size.
Directions / Method
I won't give full, explicit directions for applying these "algorithms", but simply:
- Memorization is the same as for any buffer (Buffer here is around DFR): Start at buffer, list all cycles' 2-swap resolution. Note that only midges may have orientation at all, so for wings and centers you only have permutation (make sure you understand how midges are different. If you understand M2, they should pose no problem, though). Pairs work very well for memo. See Chris Hardick's explanation of big cube BLD for a start.
- Execution follows exactly these algorithms in order. Treat these as 2-swaps with the buffer.
- IMPORTANT: If the r/m-slice is off, shoot the opposite location on the slice). This only happens on the 2nd/4th/6th piece if it is on the r-slice and not the buffer/UBR piece.
- For parity, shoot an extra piece indistinguishable from the buffer or use a parity 2-swap alg. Be careful on supercubes, and note that center parity matches corner parity and midge parity.
Notation
- URFBDL are standard: outer slices/layers.
- In order to keep MES analogous to a 3x3x3 simulated using outer slices, I define them to affect all non-outer slices: M = x'RL'.
- Similar to inner slices, mes now represent the very inner slices on odd cubes. This way, "M is everything between R and L, while m is between r and l." Note that on 3x3x3, MES = mes.
- All piece types are exchangeable with a buffer piece (on D, toward F and R) that lies on an r slice that is nth inward form R. For each piece type below, urfbdl refer to that nth inward slice.
For 4x4x4 and 5x5x5, this is the second slice in.
- "Oblique" centers (which apppear on 6x6x6 and higher-order cubes) also lie an mth slice inward from F - the analagous mth inward slices (from URFLBD) will (respectively) be called τρφλβδ. Note that m may be less or greater than n.
- Also, make sure to turn only those slices described in an algorithm, unless you really know what you're doing.
- Compact notation shows the essential structure of an alg. It uses commutator and conjugate notation. [A, B] = A B A' B' , and [A: B] = A B A'.
Piece Labeling
- There are 7 different types of pieces: Edges/Midges, Wings, Corners, Middle Centers, X-Centers, T-Centers, and "Oblique" Centers:
- Edges/Midges are the middle pieces on the outer edges of odd cubes. There are n mod 2 orbits of 12 of these on an nxnxn (n>2). The m2 buffer is DF.
- Wings are the pieces on the edges other than midges. There are floor(n/2)-1 orbits of 24 of these on an nxnxn. The r2 buffer is DFr.
- Corners are the pieces on the corners of a cube. I will not be considering corners for r2. There is 1 orbit of 8 of these on an nxnxn. (The R2 buffer is DFR.)
- Middle centers are the very middle centers on the faces of odd cubes. Because they use a standard orientation to memorize, most BLD cubers place these in a standard orientation, and thus their permutation is trivial (and in supercubes there is only orientation). There are n mod 2 orbits of 6 of these on an nxnxn. (There is no buffer, but it can be taken as D for consistency.)
- X-Centers are the centers on the diagonal (except middle centers) between corners. There are floor(n/2)-1 orbits of 24 of these on an nxnxn. The r2 buffer is Dfr.
- T-Centers are the centers between middle centers and between midges (I used to call them "+ centers," but switched to Chris Hardwick's and Daniel Beyer's name for cosistency, and to avoid using non-letters in names). There are (floor(n/2)-1)*(n mod 2) orbits of 24 of these on an nxnxn. The r2 buffer is Df.
- "Oblique" Centers are the centers not described before, off at an "oblique," non-orthogonal/diagonal angle from X-Centers and T-Centers (I came up with the name while searching for a term to describe them; I haven't found a better one, and so I will use it here). These can all be treated similarly for r2. There are (floor(n/2)-2)*(floor(n/2)-1) orbits of 24 of these on an nxnxn. The r2 buffer is Dfr.
- Note that pieces are labeled by their proximity to faces -any faces they lie on are UPPERCASE, other faces' letters are lowercase (for midges and corners in particular, the first letter denotes the face of the sticker in the cycle). Note that most piece types are distinguishable by their labeling -only X-Centers and Oblique Centers are labeled identically, but the latter currently do not come under much consideration for BLD.
Supercubes
Exactly the same algs apply to supercubes. I have purposely excluded algs that do not work on supercubes (or would involve modification/etc on supercubes), except where a significantly shorter alternative solution exists for non-supercubes. These are marked with an adjacent arrow:
(↑) (NSFSC is too long for denoting algs that are not super-safe...). Simply avoid these, and use supercube-safe corner algs (and find some way to deal with middle centers and parities).
"Algorithms"
These algorithms should mainly be intuitive and easy to understand; you should actually try to see how they work and find all of them by yourself -afterwards, you can look here to see if I have any better algs ones for your worst cases. I have tried to avoid putting in cube rotations or extra moves to present the method in its most direct, simple form. Note that all algs effectively cycle the buffer (DFR-ish) to the target (the current piece in the cycle, which is at the buffer) to the helper (UBR-ish) back to the buffer, followed by r2/m2 (which sometimes cancels with the final move of the commutator). It's a pseudo-2-cycle achieved by turning the entire r/m-slice to utilize a swap of the buffer and helper and generate a "2-swap" (all these are self-inverses, except for targets on the r/m-slice).
So that you don't have to search below to find all types, here is a list of all commutator types/ideas used below:
- [[U':L']:r2] (FLu), [[R,b']:r2] (Rbd) - Simplest exchange with helper.
[F:[[U':l'],r2]]r2 (Fdl) - Adapted via conjugate. A lot of algs use this, and every piece can essentially be done this way: [move away target:[pick up with helper,r2]]r2.
- [r'[U:L]:r2] (BLu), [r'[u:L2]:r2] (Ldb) - Variant of previous.
- [[U:L']:[[U':L],r2]]r2 (UFl) - Another variant example.
- [D:[[U:R2],r2]]r2 (UFr) - my alg to shoot UF/UFr, which resembles other r2 algs.
- [F:[d,[R:U]]]r2 (UFr) - Erik's way to shoot UF/UFr.
- [[U:R'][B':R2]:r2] (UBl) - My way to shoot BU/UBl. [UB'RU'B:m2'] is more efficient, and some people prefer [[U:R']R[B':R]:r2].
- [U2,m']m2' (UF), [f2,[m':B2]]m2' (Uf) - 3-cycle on m, followed by m2'.
- [D2y':[[r',U],l2]]r2 (Urf)- r2 (done as l2) from a different perspective (Ulb mirrored).
- [[D':b]:r2] (Rbd)- Shooting directly on b by moving r-pieces out of the way.
- [U':[[D':l2],r2]]r2 (Urf) - Utilizing a comm for opposite centers as the basic cycle.
- [s:[[b':R'],m2']]m2' (Ur) - Commutator applicable to T-centers.
Be free
Don't restrain yourself to these "algs". This is essentially a consistent, slightly lenghty commutator for every pair of pieces. You can substitute a commutator at any point (but be careful with pieces on the r slice when it's off). If a pair in a cycle is (DFr>)UFr>BRu, [r,ULU'] works perfectly well (note that r-slice pieces are the worst, but exchangeable with the buffer and thus make easy comms). See
here.
Also, these are just my commutators, the ones I could think of that are easy to visualize and use; there are probably a few good unexplored variations, so don't adopt any of mine without a little care.
A good suggestion that I got from Daniel Beyer (regarding wings) is to use r2 for pieces on L and R, but commutators instead of long algs for pieces on M-slices. Mike Hughey adopted this and is doing well with it (he got 12 sucesses in a row after trying it!). Do whatever satisfies your desire and for ease, accuracy, and speed...
Parity
- Note that for parity (when an odd number of pieces have to be shot), r2/m2 will be off. Shoot the helper in order to be left with a 2-swap of the buffer and helper.
- Parity is easily dispensed with by shooting an extra piece that is identical to the buffer (so this only applies to centers on non-supercubes), like Dfl or Dl.
- For wing parity, I use r' U2 r2 U2 r U2 r U2 r2 l U2 r' U2 r U2 l' U2. However, the following may be more intuitive/easier to remember: { (U2r)*5 U2 (Shoot UFr) (Shoot DBr) (Shoot UBr/r2) }. Both of these algs exchange the left and right columns of centers between them (respectively, UFl to UFb and UFr to UFb), so don't do this until centers are done, and be careful on supercubes. For a super-4x4x4, (RUR'U)*5 resolves centers, but I'll leave for you to figure out how to resolve supercube T-Center and Wing parity together...
- For midge/corner parity, I suggest { m2' (Shoot UF) m2' }. Then do { r (Flip UB = Shoot UBr without final r2) r'l' (Unflip UB/Un-Shoot UBr) l} to ALL r and l slices (simultaneously). This will leave UF and UB switched. You can, say, apply a T-Perm to resolve edge parity with corner parity (Be aware that this will affect centers -the standard T-Perm does U' to the entire U-Center).
- For even cube corner parity, I suggest using the standard PLL parity alg to create a 2-edge swap, and then resolving as in 3x3x3 BLD.
- Have fun with supercubes. Try things like [U,[m:e]] for middle center orientation. Don't do anything weird, make sure you know what your special resolvent algs do, and and figure out the necessary solutions "on the fly" until you are comfortable (or alternatively, prepare fixes).
Miscelaneous Notes
- You can of course use any of this at any level. Feel free to do freestyle or commutators for centers or midges, but r2 on wings... Just be careful so you don't get frustrated by incompatibilities. You can even use a comm to solve any two pieces in a cycle, or use a URB piece for a commutator buffer and switch to r2 when you want to split up a nasty commutator.
- I haven't specified half-turn directions in the algs. Do what ever is convenient and fast. I do suggest either double-triggering r2/m2' or doing them in some other consistent way.
3x3x3 Edges / Big(Odd)-Cube Midges
| Target | Algorithm | Compact |
| UF | U2m'U2m'(↑)
m'U2mU2m'U2mU2m2' | [U2,m']m2'
[m',U2][m',U2]m2' |
| FU | Dm'UR2U'mUR2U'D'm2'
FeRUR'e'RU'R'F'm2' | [D:[m',[U:R2]]]m2'
[F:[e,[R:U]]]m2' |
| UL | LU'L'Um2'U'LUL' | [[L,U']:m2'] |
| LU | BL'B'm2'BLB' | [[B:L']:m2'] |
| UB | m2' | m2' |
| BU | UR'U'B'R2Bm2'B'R2BURU'
UB'RU'Bm2'B'UR'BU' | [[U:R'][B':R2]:m2']
[UB'RU'B:m2'] |
| UR | R'URU'm2'UR'U'R | [[R',U]:m2'] |
| RU | B'RBR'm2'RB'R'B | [[B',R]:m2'] |
| FL | U'L'Um2'U'LU | [[U':L']:m2'] |
| LF | BL2B'm2'BL2B' | [[B:L2]:m2'] |
| LB | L'BLB'm2'BL'B'L
mULU'm2'UL'U'm' | [[L',B]:m2']
[m[U:L]:m2'] |
| BL | U'LUm2'U'L'U | [[U':L]:m2'] |
| BR | UR'U'm2'URU' | [[U:R']:m2'] |
| RB | RB'R'Bm2'B'RBR'
mU'R'Um2'U'RUm' | [[R,B']:m2']
[m[U':R']:m2'] |
| RF | B'R2'Bm2'B'R2B | [[B':R2']:m2'] |
| FR | URU'm2'UR'U' | [[U:R]:m2'] |
| DF | - | - |
| FD | - | - |
| DL | U'L2Um2'U'L2U | [[U':L2]:m2'] |
| LD | BLB'm2'BL'B' | [[B:L]:m2'] |
| DB | mU2mU2(↑)
m2'U2m'U2mU2m'U2m | m2'[m',U2]
m2'[U2,m'][U2,m'] |
| BD | m2'DUR2U'm'UR2U'mD'
m2'FRUR'eRU'R'e'F' | m2'[D:[[U:R2],m']]
m2'[F:[[R:U],e]] |
| DR | UR2U'm2'UR2U' | [[U:R2]:m2'] |
| RD | B'R'Bm2'B'RB | [[B':R']:m2'] |
Wings
X-Centers
| Target | Algorithm | Compact |
| Ubr | r2 | r2 |
| Urf | U'D'l2Dr2D'l2Dr2Ur2
D2y'r'UrU'l2Ur'U'rl2yD2r2 | [U':[[D':l2],r2]]r2
[D2y':[[r',U],l2]]r2 |
| Ufl | lFU'l'Ur2U'lUr2F'l'r2 | [lF:[[U':l'],r2]]r2 |
| Ulb | lU'l'Ur2U'lUl'
b'Rbr2b'R'b
bLb'r2bL'b' | [[l,U']:r2]
[[b':R]:r2]
[[b:L]:r2] |
| Fur | F'U'l'Ur2U'lUr2Fr2 | [F':[[U':l'],r2]]r2 |
| Frd | F2U'l'Ur2U'lUr2F2r2 | [F2:[[U':l'],r2]]r2 |
| Fdl | FU'l'Ur2U'lUr2F'r2 | [F:[[U':l'],r2]]r2 |
| Flu | U'l'Ur2U'lU | [[U':l']:r2] |
| Luf | bL'b'r2bLb' | [[b:L']:r2] |
| Lfd | bL2b'r2bL2b' | [[b:L2]:r2] |
| Ldb | L2bL'b'r2bLb'L2
r'uL2u'r2uL2u'r | [L2[b:L']:r2]
[r'[u:L2]:r2] |
| Lbu | LbL'b'r2bLb'L'
D'b'Dr2D'bD | [[L,b]:r2]
[[D':b']:r2] |
| Bul | BU'lUr2U'l'Ur2B'r2 | [B:[[U':l],r2]]r2 |
| Bld | U'lUr2U'l'U | [[U':l]:r2] |
| Bdr | B'U'lUr2U'l'Ur2Br2 | [B':[[U':l],r2]]r2 |
| Bru | B2U'lUr2U'l'Ur2B2r2 | [B2:[[U':l],r2]]r2 |
| Rub | R2b'R'br2b'RbR2
rd'R2dr2d'R2dr' | [R2[b':R']:r2]
[r[d':R2]:r2] |
| Rbd | Rb'R'br2b'RbR'
D'bDr2D'b'D | [[R,b']:r2]
[[D':b]:r2] |
| Rdf | b'R'br2b'Rb | [[b':R']:r2] |
| Rfu | b'R2br2b'R2b | [[b':R2]:r2] |
| Dfr | - | - |
| Drb | D'r2U'l2Ur2U'l2UDr2
U2yUr2U'r2l2r2Ur2U'l2y'U2r2 | [D':[r2,[U':l2]]]r2
[U2y:[[U,r2],l2]]r2 |
| Dbl | l'FU'l'Ur2U'lUr2F'lr2 | [l'F:[[U':l'],r2]]r2 |
| Dlf | U'l2Ur2U'l2U | [[U':l2]:r2] |
T-Centers
| Target | Algorithm | Compact |
| Ub | m2' | m2' |
| Ur | r'UrU'm2'Ur'U'r
sb'R'bm2'b'Rbm2's'm2' | [[r',U]:m2']
[s:[[b':R'],m2']]m2' |
| Uf | f2m'B2mf2m'B2m'
md2m'U2md2m'U2m2'
U'r'UUrU'm2'Ur'U'm2'U'rUm2' | [f2,[m':B2]]m2'
[[m:d2],U2]m2'
[[U':r']:[[U:r],m2']]m2' |
| Ul | lU'l'Um2'U'lUl'
s'bLb'm2'bL'b'm2'sm2' | [[l,U']:m2']
[s':[[b:L],m2']]m2' |
| Fu | FUrU'r'm2'rUr'U'm2'F'm2'
Dm'Ur2U'mUr2U'D'm2'
FferUr'e'rU'r'f'F'm2' | [F:[[U,r],m2']]m2'
[D:[m',[U:r2]]]m2'
[Ff:[e,[r:U]]]m2' |
| Fr | UrU'r'm2'rUr'U' | [[U,r]:m2'] |
| Fd | F'UrU'r'm2'rUr'U'm2'Fm2' | [F':[[U,r],m2']]m2' |
| Fl | U'l'Ulm2'l'U'lU | [[U',l']:m2'] |
| Lu | bL'b'm2'bLb' | [[b:L']:m2'] |
| Lf | bL2b'm2'bL2b' | [[b:L2]:m2'] |
| Ld | bLb'm2'bL'b' | [[b:L]:m2'] |
| Lb | L'bLb'm2'bL'b'L
D'b'Dm2'D'bD | [[L',b]:m2']
[[D':b']:m2'] |
| Bu | B'Ur'U'm2'UrU'm2'Bm2' | [B':[[U:r'],m2']]m2' |
| Bl | U'lUm2'U'l'U | [[U':l]:m2'] |
| Bd | m2'DUr2U'm'Ur2U'mD'
BUr'U'rm2'r'UrU'm2'B'm2'
m2'FfrUr'erU'r'e'f'F' | m2'[D:[[U:r2],m']]
[B:[[U,r'],m2']]m2'
m2'[Ff:[[r:U],e]] |
| Br | Ur'U'm2'UrU' | [[U:r']:m2'] |
| Ru | b'Rbm2'b'R'b | [[b':R]:m2'] |
| Rb | Rb'R'bm2'b'RbR'
D'bDm2'D'b'D | [[R,b']:m2']
[[D':b]:m2'] |
| Rd | b'R'bm2'b'Rb | [[b':R']:m2'] |
| Rf | b'R2bm2'b'R2b | [[b':R2]:m2'] |
| Df | - | - |
| Dr | Ur2U'm2'Ur2U' | [[U:r2]:m2'] |
| Db | mB2mf2m'B2mf2
m2'U2md2m'U2md2m'
D'rDUrU'm2'Ur'U'm2'D'r'Dm2' | m2'[[m':B2],f2]
m2'[U2,[m:d2]]
[[D':r]:[[U:r],m2']]m2' |
| Dl | U'l2Um2'U'l2U | [[U':l2]:m2'] |
"Oblique" Centers
| Target | Algorithm | Compact |
| Ubr | r2 | r2 |
| Urf | ρ'UρU'r2Uρ'U'ρ | [[ρ',U]:r2] |
| Ufl | lFUρU'r2Uρ'U'r2F'l'r2 | [lF:[[U:ρ],r2]]r2 |
| Ulb | λU'λ'Ur2U'λUλ' | [[λ,U']:r2] |
| Fur | FUρU'r2Uρ'U'r2F'r2
FφdρUρ'd'ρU'ρ'φ'F'r2 | [F:[[U:ρ],r2]]r2
[Fφ:[d,[ρ:U]]]r2 |
| Frd | UρU'r2Uρ'U' | [[U:ρ]:r2] |
| Fdl | FU'λ'Ur2U'λUr2F'r2 | [F:[[U':λ'],r2]]r2 |
| Flu | U'λ'Uλr2λ'U'λU | [[U',λ']:r2] |
| Luf | βL'β'r2βLβ' | [[β:L']:r2] |
| Lfd | βL2β'r2βL2β' | [[β:L2]:r2] |
| Ldb | βLβ'r2βL'β'
r'τL2τ'r2τL2τ'r | [[β:L]:r2]
[r':[[τ:L2]:r2]] |
| Lbu | L'βLβ'r2βL'β'L
D'β'Dr2D'βD | [[L',β]:r2]
[[D':β']:r2] |
| Bul | B'Uρ'U'r2UρU'r2Br2 | [B':[[U:ρ'],r2]]r2 |
| Bld | [[U'λ]:r2] | [[U'λ]:r2] |
| Bdr | U'U'λUr2U'λ'Ur2Ur2 | [U':[[U':λ],r2]]r2 |
| Bru | Uρ'U'r2UρU' | [[U:ρ']:r2] |
| Rub | β'RβR'r2Rβ'R'β | [[β',R]:r2] |
| Rbd | Rβ'R'βr2β'RβR'
r'τ'R'τr2τ'Rτr
D'βDr2D'β'D | [[R,β']:r2]
[r':[[τ':R']:r2]]
[[D':β]:r2] |
| Rdf | β'R'βr2β'Rβ | [[β':R']:r2] |
| Rfu | β'R2βR2r2R2β'R2β | [[β',R2]:r2] |
| Dfr | - | - |
| Drb | Uρ2U'ρ2r2ρ2Uρ2U' | [[U,ρ2]:r2] |
| Dbl | l'FU'λ'Uλr2λ'U'λUr2F'lr2 | [l'F:[[U',λ'],r2]]r2 |
| Dlf | Uλ2U'λ2r2λ2Uλ2U' | [[U,λ2]:r2] |