# APB - An efficient, ergonomic, algorithmic, 2x2x3 based method

#### Athefre

##### Member
So, what is the final alg count for all pair situations?

For dl, is it just ~64 cases for dFR and ~64 cases for dBR? Or am I missing some?
For using the same pair every solve, which is my recommendation until really advanced use, it is 63 EOPair algorithms and 116 L3P algorithms. For a total of 179 algorithms.

Oriented pair EOPair: 31
Misoriented pair EOPair: 32
L3P: 116

Later you can learn the algorithms for when the pair is a move away from being paired. Or algorithms for other pairs. There will be new L3P algorithms for each pair. It is possible to use the same EOPair algorithms for various pairs.

Added a Beginners page with a simple strategy for the algorithm learning process. The summary is that if you don't know the alg for the current EOPair case, insert the pair then use one of 11 algs to orient all edges. Then if you don't know the alg for the current L3P case, insert the D layer edge (just two easy cases) then solve the remaining F2L pair.

#### tsmosher

##### Member
For using the same pair every solve, which is my recommendation until really advanced use, it is 63 EOPair algorithms and 116 L3P algorithms. For a total of 179 algorithms.

Oriented pair EOPair: 31
Misoriented pair EOPair: 32
L3P: 116

Later you can learn the algorithms for when the pair is a move away from being paired. Or algorithms for other pairs. There will be new L3P algorithms for each pair. It is possible to use the same EOPair algorithms for various pairs.

My question was more around how practical it would be to learn all EOPair cases for a given slot and a given 223 orientation.

e.g., If I always build a 223 in dl, and I always want to insert dBR as my EOPair, how many cases would I have to learn in order to cover all F2L scenarios (i.e., make this step entirely algorithmic)?

For the record, I assume this would be a huge number, at least as large as ZBLS (302 cases).

#### Athefre

##### Member
My question was more around how practical it would be to learn all EOPair cases for a given slot and a given 223 orientation.

e.g., If I always build a 223 in dl, and I always want to insert dBR as my EOPair, how many cases would I have to learn in order to cover all F2L scenarios (i.e., make this step entirely algorithmic)?

For the record, I assume this would be a huge number, at least as large as ZBLS (302 cases).

I put it into trangium's batch solver and it showed a little over 2,000 cases. This would be to orient all edges while solving the dBR pair no matter where the corner and edge is.

#### Athefre

##### Member
I have updated the main post with much more detail on why this method is great, comparisons, expansions, and a simple guide for someone new to the method. The website has also been updated with some of these same things.

#### voidrx

##### Member

Here I am presenting a new method which efficiently reaches ZBLL without the requirement of efficient blockbuilding for most of the solve or the memorization of 400+ algorithms before ZBLL. The primary steps are:

Step 1: Build a 2x2x3 on the left.
Step 2: Create the F2L pair that belongs in the back (DBR + BR edge) and keep it on the U layer. This is 3-4 moves.
Step 3 (EOPair): Orient all edges while inserting the pair. There are 63 total cases averaging 5.76 moves.
Step 4 (L3P): Solve the final three pieces (FR + DR edge + DFR corner). This step contains 116 algorithms averaging around 8.59 moves.
Step 5: ZBLL

The recommendation is to always create the back pair (dBR) in Step 2. This provides the best recognition for the proceeding steps and is also the most efficient option. It is also possible to create the 2x2x3 in the back in APB. This is actually the most efficient overall but has R r U M ergonomics for the L3P step versus all R U if the block is on the left. The algorithms for 2x2x3 at db are also provided on the website. For LL, ZBLL is the ultimate goal. OCLL+PLL is also great to use with APB. Users would average 50-52 moves with that simple two step LL method.

In total versus alternatives, APB is efficient, requires many fewer algorithms, and is more ergonomic. The total average move-count considering a 12 move 2x2x3 and including AUFs for all steps is ~45 moves. This is achieved without requiring the memorization of a few hundred algorithms as in alternative methods such as Mehta. Comparing against the same method, APB's EOPair step contains 63 algorithms that are slightly more ergonomic and average the same move-count as the 56 EOLE algorithms. The L3P step contains 116 shorter, more ergonomic algorithms versus 350 longer, less ergonomic algorithms in TDR. Comparing to Petrus, there is no mid-solve recognition of seven edges, APB is more efficient, and is also more ergonomic due to the refined algorithms for each step. In Petrus a user can't always choose the most efficient or most ergonomic solution.

Pros:
• More efficient than EO + last block in Petrus
• Algorithmic for most of the solve. Everything after 2x2x3 can be algorithmic which would be 70-75% of the solve.
• More ergonomic than algorithmic alternatives and intuitive blockbuilding
• Expandable for further move-count reduction or for non-ZBLL use
• Very easy to solve each algorithm step intuitively while learning
• No rotation required
• Can track EO while creating the pair
Cons:
• Memorization versus intuition
• Involves EO recognition. Requires checking the orientation of five edges similar to other methods.
• Pseudo application for those that have an interest in using that means creating a pseudo pair. Creating a pseudo pair requires a different kind of recognition from a normal pair.
Steps in Detail:

Step 1:
There are many ways to build a 2x2x3. The most well known option is 2x2x2 then expand to 2x2x3. Another way is to build a 1x2x3 on the L layer or D layer then add the two remaining edges with their centers. There are other ways of building a 2x2x3 so it may be best to choose the way that works best for the current scramble. As Trangium pointed out, the 1x2x3 then two edges option removes the necessity for efficient blockbuilding. And for an advanced solver, planning the full 2x2x3 in inspection, using any method, also means there is no need to focus on blockbuilding and thinking time. This is because the full 2x2x3 solution is known and the proceeding steps are algorithmic.

Step 2: Creating the pair can be done using just R and U moves. F or even S moves can also work well depending on the situation. There aren't that many possible orientations and positions for this corner and edge. So after a while it will be a very natural, almost algorithmic step.

Step 3: During the previous step, track the other E layer edge. Then once you get to this step (EOPair) it is easy to recognize the recognition of the remaining edges. Since you know where the other E layer edge is and its orientation, the other edges are U/D edges and the recognition is similar to Roux LSE. If a U/D color isn't facing U or D, then it is misoriented. Credit to Trangium for this observation.

Step 4: Recognition for this step is easy. The DFR corner and FR and DR edges look different from everything else that belongs on the U layer. So just find those pieces. You can track them during the EOPair algorithm execution.

Step 5: As mentioned, ZBLL is the recommendation. But it isn't necessary to be fast. APB is still a top method even without ZBLL. So choose what you are most comfortable with at first.

How to get started:

It is very easy to solve each step of APB intuitively while learning the algorithms. For Step 3 (EOPair), if you come across an EOPair case that you don't yet know, insert the pair that you created. Then orient all edges using one of 11 algorithms that are provided in the EOPair document on the website. For Step 4 (L3P), if you come across a case that you don't yet know, you can insert the DR edge intuitively by using S' U2 S if it is on the U layer or R' U' R' U R if it is at FR. Then just solve the last slot pair.

Expansions:

The EOPair step can be expanded to further reduce the move-count of APB. In Step 2 of creating a pair, you can instead set up a pair so that it is a move or two away from being paired. Then the EOPair step would finish and insert the pair while orienting the remaining edges. You can also build one of the other three possible F2L pairs if the opportunity is good. Then use the associated EOPair and L3P algorithms. This would save moves during the pair creation step and is likely best used at an advanced level.

APB also has the ability to end the solve in ways other than ZBLL. One main option is to add the opposite side F2L pair after the EOPair step then finish with CDRLL and L5EP. This would be a pretty efficient alternative to learning ZBLL. Another primary option is to expand the EOPair step to become EOSquare. After the 2x2x3 and creating a pair, the next step can place the pair while orienting all edges and solving the DR edge. This allows the user to end the solve with LSLL. There are some great LSLL developments occurring right now and likely more to come in the future. It is possible that there could be something better developed than LS + ZBLL.

Application to other methods:

Some of APB can also be used in other methods. Specifically the L3P step. In a method that already has all edges oriented before getting to the right side block, the user can create a pair, leave it on the U layer to save moves versus inserting the pair, then use an algorithm that solves the three remaining pieces while inserting the created pair. This allows for around a 13 move right block solution. Recently 𝝅/Sosimomonon tested right block using the HARCS program. They discovered that solving a pair first then solving the remaining square (L3P) is more efficient than solving a square first then the final pair. This aligns with the efficiency of APB.

Block on Left Example:

Scramble:
B2 L2 B D2 F2 L2 F L2 B L2 R2 U2 R' D' B U' R2 B L2 R2 D'

2x2x2: y z D' B' M' B'
2x2x3: F' R2 U' R U R' F
Pair: R2 U' R
EOPair: U2 F' U F R
L3P: R' U' R U R U R U R'
ZBLL: F R' F2 R F R' F2 R U2 r U r' F' U'

View on alg.cubing.net

Block on Back Example:

Scramble:
D' R2 B R2 D B2 R' U D2 R' U2 L D2 R2 B2 L' F2 R F2 U2 B'

2x2x2: D' R' U2 R F R2
2x2x3: U' L' F2 L' U L'
Pair: R U R'
EOPair: U' R U' R' U' F'
L3P: r U2 r' U2' r U2 M U R'
ZBLL: R' U' R U R2 D' R U' R' D R2 U2 R' U2 R

View on alg.cubing.net

Some may ask "Is this Petrus?" APB was originally developed with the intent to fix the common complaint against Petrus which is the EO step. The EO step of Petrus is a bit of an inefficiency. It may only be ~5 moves but I've always felt that there should be something more done while orienting the edges. So with APB, instead of separating EO and the last block, partial blockbuilding is performed while orienting the edges. At first APB could have been viewed as algorithmic Petrus. But it has since been expanded to have the ability to end in different ways that aren't LL and part of the method has been adapted to work with ZZ, LEOR, and other methods. APB has developed into something unique of its own.

The update is great!!

One little thing... It is actually faster to put the DR edge in UL and do S R2' S' R2 than to put the DR edge in UR and do S' U2 S.

#### Athefre

##### Member
The update is great!!

One little thing... It is actually faster to put the DR edge in UL and do S R2' S' R2 than to put the DR edge in UR and do S' U2 S.
I think I can do S' U2 S faster. Both are good though so maybe I'll add that as an option on the site.

#### OreKehStrah

##### Member
The update is great!!

One little thing... It is actually faster to put the DR edge in UL and do S R2' S' R2 than to put the DR edge in UR and do S' U2 S.
S' U2 S should be faster. A double flick U2 is faster than a rolled or overturned R2.

#### tsmosher

##### Member
Yeah but here you do R2' from homegrip(dlin Ub style) and S' U2 S has an overwork
S' U2 S is faster If the edge is in URS IMHO. Any other spot, you can AUF the edge to ULS and do it the Mehta way.

#### Athefre

##### Member
A comparison of the three 2x2x3 + EO + RB methods - Petrus, APB, and Mehta.

More detail below. The table compares the F2L part of each method. LL isn't included because it is the same for all three. A rating system of 1-5 was used in the chart for ergonomics and recognition. That was just a way to quantify them and show differences. The exact numbers don't matter so much because we can debate how far from 5 something should be and if something should be .1 higher or lower. It is more important to see the differences in ergonomics and recognition as described below. That will help show why a step was rated .2 higher than another step.

Movecount: The movecounts among all three are so close that it probably doesn't even matter. It is pretty much a draw and little things here and there can put any of the three over the others. Things like the skill of the user, how the build the 2x2x3, algorithm choice, pseudo integration, and others. Petrus users often say that a good user should average 12 moves for a 2x2x3 using the 2x2x2 > 2x2x3 strategy. The table bases the 2x2x3 step on this number and should be around the same when using another single strategy. The 2x2x3 for Mehta is input as 11 moves due to the method using a strategy of 1x2x3 on the D layer then any two edges in a pseudo way. This equates to a 6 move 1x2x3 and 5 moves for two E layer edges. I'm not sure if users will actually average this low. I'm just using the 1x2x3 number from the Mehta website. If pseudo is used there will often be a final D or E layer adjustment (ABF in the table). Using a few techniques depending on the scramble to build a 2x2x3 is likely more efficient than always using the same strategy. This is the recommendation in APB so it could also go below 12 moves. Despite the overall movecounts of each method being close to the same, it is likely much more important to consider the movecount of the algorithm-based steps. This means EOPair vs EOLE and L3P vs TDR. EOPair and EOLE are almost exactly the same. The biggest difference is in L3P and TDR where L3P averages over a move fewer. This advantage is especially important when considering the ergonomics of the steps which is talked about in the ergonomics section below.

Algorithm Count: Petrus contains zero algorithms before the last layer. The EO step can be performed using algorithms if the user wants. APB's EOPair step contains 63 algorithms and L3P contains 116 algorithms for a total of 179 algorithms. Mehta's EOLE step contains 56 algorithms and TDR contains 350 algorithms for a total of 406 algorithms. This means that a user has to learn 227 more algorithms in Mehta. In L3P vs TDR this means the user needs to learn 234 additional, longer algorithms.

Ergonomics: Although the final steps of each is R U only there will be a difference. In Petrus the user isn't going to always be able to choose the most ergonomic solution because it is intuitive. In APB and Mehta the final step uses speed optimal algorithms. These will be both ergonomic and drilled by the user to be performed quickly. APB's final step, L3P, contains algorithms that are a bit more ergonomic than Mehta. With L3P averaging fewer moves than TDR, the better ergonomics combine to give this step a real advantage. L3P containing just 116 cases versus TDR's 350 widens the gap further. In APB's EOPair and Mehta's EOLE, there is a very slight ergonomics advantage in APB's favor. The ergonomics advantage of APB's EOPair versus Mehta's EOLE is further evidenced when putting the algorithm lists into trangium's MCC program. The advantage of L3P versus TDR can be seen when performing the algorithms and considering that APB's L3P step is more free. A full slot is available so many algorithms will be as ergonomic as a last slot algorithm. The L3P step is also solving one corner and two edges. TDR solves two corners and one edge. It is more difficult to work with two corners than it is two edges.

Recognition: Mehta's EOLE has a slight advantage vs APB's EOPair. With EOPair the user tracks the other E layer edge during lookahead while building the pair in the previous step. Neither step has difficult recognition, so they both were rated pretty highly. For L3P vs TDR, I feel that L3P has slightly better recognition because a corner has more stickers and the D layer stickers that you want to find can be hidden. L3P has only one corner to find. Edges are easier to find because you just check the U layer (and or the FR sticker in L3P's case). Again though, lookahead is something all solvers should be doing so neither step has bad recognition. Recognition is a tie overall for the two methods. Petrus only has one step during F2L that requires recognition. That is the EO step and is one of the major complaints against the method.

In summary, the primary differences are in the algorithm count and ergonomics. Those two qualities should be the main focus when comparing the methods. Petrus contains zero algorithms for EO F2L, but has slightly worse ergonomics and recognition. For the algorithm-based approaches, APB contains many fewer algorithms than Mehta. APB is a little more ergonomic than both Petrus and Mehta. So with the higher TPS potential of an algorithm-based approach, APB achieves better ergonomics and the same move-count and recognition without requiring the user to learn a huge number of algorithms.

#### Cubing Forever

##### Member
The ergonomics advantage of APB's EOPair versus Mehta's EOLE is further evidenced when putting the algorithm lists into trangium's MCC program.
can you give the numbers for this(as in average movecount coefficient for EOLE and EOPair)?

#### Athefre

##### Member
can you give the numbers for this(as in average movecount coefficient for EOLE and EOPair)?
Yeah:

EOPair:
• Oriented pair (31 cases) - 7.34 MCC
• Misoriented pair (32 cases) - 8.27 MCC
• All algorithms (63 cases) - 7.81 MCC

EOLE:
• All algorithms (56 cases) - 8.43 MCC
I think both EOPair and EOLE can be further optimized. I'm just one person and EOLE has had a lot of people work on that alg set.

#### voidrx

##### Member
APB-CP

1. CP-line
2. FB
3. Solve dM
4. APB (Some algs might be different??)
5. 2GLL

#### OreKehStrah

##### Member
I don't know about EOpair but EOLE for sure needs more optimization(since there are some algs with funny ergonomics(eg. F R F2 U F R'))

Bruh, R F' U F R' to solve the case set up by the inverse of that

#### Athefre

##### Member
APB-CP

1. CP-line
2. FB
3. Solve dM
4. APB (Some algs might be different??)
5. 2GLL
Yep. APB can be used in methods with edges already oriented. The same algs for ZZ that are provided on the site can be used in LEOR, CP methods, and others. Currently the site has dFR algs. It would be nice to have the dBR algs added.
Bruh, R F' U F R' to solve the case set up by the inverse of that
That alg is in the main document that I used for the numbers.

#### tsmosher

##### Member
The 2x2x3 for Mehta is input as 11 moves due to the method using a strategy of 1x2x3 on the D layer then any two edges in a pseudo way. This equates to a 6 move 1x2x3 and 5 moves for two E layer edges. I'm not sure if users will actually average this low. I'm just using the 1x2x3 number from the Mehta website. If pseudo is used there will often be a final D or E layer adjustment (ABF in the table). Using a few techniques depending on the scramble to build a 2x2x3 is likely more efficient than always using the same strategy.

I thought the estimates for this were always: 7 moves for Dl and 7-8 moves for 3QB. With 5 of these moves being HB, that would be 12 moves for 223 just like the other methods.

I don't think 6 moves for FB is realistic. (Maybe for a computer/FMC but not a speed solver.) For most of us mere mortals, I would estimate 7-8 moves for Dl and 3QB each.