# User:Danegraphics

Steven Mortensen, also known as **Dane man** on the forums. Known for the creation of BLL and collaborating the organization of a Finger trick notation.

When it comes to cubing, he isn't into speed as much as he is into the novelty of elegant and intuitive solutions. More of his cubing time is dedicated to discovering and proposing new and different solving methods than it is practicing to be faster.

Prefers to be happy.

Sometimes writes in the third person to sound more official.

## Methods Proposed

### BLL

BLL was developed over time as his standard method of solving the cube, which he uses to this day. It can be read about and understood on the BLL page or on the forums (Thread)

### Diaper Method

*The following is copied directly from his post here.*

*This method was meant to be more silly than serious.*

- 1-Solve the cross, just as any other cross based method.
- 2-Solve the middle layer edges while simultaneously placing all of the first layer corners into the last layer. This makes the diaper shape on each side. (0-8 moves per edge HTM)
- 3-Place the first three corners in the first layer. (avg 7 moves HTM).
- 4-The last corner will be placed while simultaneously orienting the last layer edges. (24 algs, 14 excluding mirrors. Has an average of 9 moves HTM. The smallest of these algs are used in step 3.)
- 5-LL as desired starting with already oriented edges.

While it doubles the moves for the F2L to be completed, it also orients the LL edges, allowing for the interesting variations of the LL with edges oriented.

The benefits of this algorithm are that you get the same effect as ZB, but with much fewer algorithms. The cons are that it is complicated and tricky to learn. Not only that, but compared to ZZ, there are algorithms to learn to finish the F2L with the LL edges oriented. Really, not a speed method. Just a fun experimental one.

Algorithms for step 2 are intuitive. Like Fridrich F2L, except half the corners are acceptable and in any orientation.

Algorithms for steps 3 and 4 can be found as a subset of ZBLS (aka ZBF2L). They are only the first eight of each page:

Making 24 in total.

### ZBLBL

*This was meant to be more serious*

This method is more efficient than the Diaper Method, modifying the LBL method by inserting the last middle edge while simultaneously orienting the LL edges (only 21 algorithms, with avg of 8 moves HTM). It is also much easier to find and insert the first layer corners, than to insert middle edges while separating corners as in step 2 of the Diaper Method. The algorithms for ZBLBL are found here and here. I recommend you try this method as well.

OLL for these methods is reduced to 7 algorithms if you go that direction (OLL/PLL). Another variation of the LL that could be done (this I'm still developing the algorithms for as well) is where one permutes the edges while orienting the corners. This step has 42 algorithms, but the resulting PLL only needs 4 algs (H, Aa, Ab, E). Though recog for the first step is slightly tricky, it still works once learned.

### Skipper F2L (SF2L)

*The following is copied directly from his thread post here*

- 1-While performing F2L, one inserts the first two pairs normally.
- 2-Insert the corner of the third pair, not worrying about its edge.

---

- 3-Insert the fourth pair (edge and corner) without worrying about the orientation of it's corner. (EUOC)
- 4-Perform CLS (24 algs: CLS:I (and mirror) + OCLL)

--or--

- 3-Insert the corner of the fourth pair, not worrying about it's edge.
- 4-Insert the edge of the fourth pair using the second step of JJLS here. (34 algs)

- 5-Insert the edge of the third pair using ZBLBL algs (Modified to respect corner orientation, 21 algs. I'm still working on making these to see the avg moves.)
- 6-You are now left with a 1LLL, being just PLL (21 algs).

A good alternative is to perform the ZBLBL *before* performing CLS, as CLS already respects the edges, and you can use the already existing ZBLBL algs.

Comparing to the standard Fridrich(CFOP) OLL/PLL:

- avg moves: F2L(6.7*4)+OLL(9.7)+PLL(11.8) =
**48.3 HTM** - avg moves: F2L(6.7*2)+C3P(~4)+EUOC(~5)+CLS(~10.5)+ZBLBL(~8.5) +PLL(11.8) =
**53.2 HTM** - avg moves: F2L(6.7*2)+C3P(~4)+C4P(~4)+JJLS2(~10)+ZBLBL(~8.5)+ PLL(11.8) =
**51.7 HTM**

The number of moves isn't reduced, though, the algorithm count is reduced a little more. (OLL/PLL = **78** algs; CLS/ZBLBL/PLL = **66** algs; JJLS2/ZBLBL/PLL = **76** algs)

The executional downsides to this method is the added recognition of inserting the corners of the third and fourth pairs to prepare for further algorithms, and the standard look-ahead of the last two F2L pairs becomes increasingly complex (not too much though, it just adds looking for 4 piece orientations per pair). The learning con is that it is quite unorthodox, and a good step out of the way of OLL because it replaces it entirely. Other than that, I see this method as being very effective, holding a lot of potential when it comes speed cubing and even (perhaps especially) FMC.

### Pet Rock

*The following is copied from this post.*

Well, I was thinking, and a very interesting method came to mind. It reduces the cube to <R, U, F2>, and solves the cube from there. Because it begins very similar to Petrus, I'd like to call it Pet rock. Here's the idea.

- 1- Solve the 2x2x2 block in the BDL corner.
- 2- Orient the edges relative to <R, U, L, D>. The freedom of having a third side to turn without restriction should make this simpler to perform.
- 3- Extend from the original the 2x2x2 block to a 2x2x3 on the F side. This is done only using <R, U, F2>. With practice, this could become very efficient.
- 4- Extend from the original 2x2x2 block to a 2x2x3 on the R side. This in combination with step 3 should leave an F2L slot and all the edges oriented. (Use only <R, U> moves)
- 5- Insert the last F2L edge/corner pair (the orientation of the corner doesn't matter, allowing faster execution). (Use only <R, U> moves. 25 cases. Avg moves 7.5, rare worst case 12)
- 6- Perform CLS (24 algs (CLS: I/CLS: I(mirror)/OCLL). This orients the rest of the corners and leaves the edges oriented, skipping OLL)
- 7- Perform PLL. Done!

Because of the nature of the method, I don't have any way of discovering the avg move count besides actually performing it myself multiple times, so I have no idea how efficient it is yet, but what I do know is that it is very intuitive until steps 6 and 7.

The total alg count is 55. The combination of CLS and PLL has an avg move count of 22.3 (compared to the OLL/PLL avg move count of 21.5). Now the question is what the average moves are for steps 1-5. From what I've tested already, it seems not to be much more than what is already common for Cross+F2L or Petrus->F2L, though I'd like to test more, and see the possible situations.

It really depends on if steps 2-4 require less moves on average than 3 F2L slots. If I were good at block building, I could probably find out. Step 2 should be quick (only two more edges than in Petrus), though steps 3 and 4 will likely take more.

Block building and inspection are important aspects of this method.

Statistical breakdown of moves required for step 5. (CoS = Chance of state, #oM = Number of moves) CoS #oM 1/25 = 0 (done) 2/25 = 3 (connected correctly on top) 2/25 = 4 1/25 = 7 (disconnected left) 3/25 = 8 1/25 = 7 (disconnected right) 3/25 = 8 1/25 = 7 (edge in, corner on top) 3/25 = 8 1/25 = 7 (corner in, edge on top) 3/25 = 8 2/25 = 11 (connected incorrectly on top) 2/25 = 12