#### Athefre

##### Member

- Joined
- Jul 25, 2006

- Messages
- 1,144

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 1:

**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'

Scramble:

**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'

Scramble:

**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.

Last edited: Nov 9, 2021