Lazy CFOP

Lazy CFOP is a speedcubing beginner method. It is very similar to beginner FreeFOP, but instead of blockbuilding, it is more into method manipulating. Basically, you solve a cube with all methods combined, but solving it in a CFOP state. The reason why it is called "Lazy" because the solve is in a CFOP step but uses different methods when it comes to hard cases. For example, if you get a hard cross, you will use a different method. You can also solve the cross unoriented. Sometimes, you will skip cross and do F2L first and then cross. (Kinda like too lazy to do hard cross or do cross.) The point of this method is to use a different method to easily execute a hard case or scramble.

Steps

There are a lot of combinations in a scramble. Therefore, the steps will be a lot of different cases and explanation.

1. Scramble case

(1)If you get an easy cross, just do plain CFOP to solve the cross.

(2)If you get an easy cross with an F2L pair solved, try to make an X-cross. If you can't, make a 2x2 block for the pair and then solve the cross.

(3)If you have 3 easy edges to do cross, you have 2 decisions:

• RouxVH: solve the last edge unoriented in the cross
• Hawaiian Koceimba: Just solve 3/4 cross and move forward to solve the F2L pairs with the missing edge cross. After F2L, Roux insert (M' U M) or (M' U2 M) the missing edge into the cross.

(4)If you have 3 easy edges to do cross, but you have an F2L pair, try making a 3/4 X-cross, 2x2 Block with three edges solved, or 2x2x3 block (if youre lucky).

(5)If you have 2 easy edges that are adjacent, you can do:

• Petrus: Make a 2x2 Block (If u can make one or find an F2L pair)
• Advanced RouxVH: Solve a cross with 2 edges unoriented.
• MCross (Misplaced Cross): Solve a cross with 2 edges misplaced.
• Lazy Petrus: Solve 2/4 cross with an F2L pair inserted in the correct place but not in between the 2 solved edges.
• Lazy Cross: Solve 2/4 cross and then solve the whole F2L Pair. Then Roux insert the missing edge pieces into the cross.
• Fake Petrus: Make a 2x2 Block, but the F2L Pair has an unoriented corner, edge, or both.

(6)If you have 2 easy edges that are opposite, you can do:

• Roux Cross: Solve 2/4 cross and then solve all F2L pairs roux style.
• ZZ Line Cross: Solve 2/4 cross and then solve 1x2x3 block on each empty side, kinda like solving 2 F2L pairs and cross at same time. (ONLY USE FOR ADVANCED ZZ CUBERS)
• Advanced RouxVH: Solve a cross with 2 unoriented.
• MCross: Solve a cross with 2 edges misplaced.
• Galaxy Cross: Solve 2/4 cross and then solve 2 F2L pairs across from each other. (Then after, do whatever, solve missing edges or remaining F2L pairs.)

(7)If you only have 1 easy edge to do cross, you can do:

• Advanced RouxVH: Solve a cross with 3 edges unoriented.
• MCross: Solve cross with 3 edges misplaced.
• FreeF2L: Solve 1/4 cross and then solve all F2L pairs Roux Style, this gives less moves to solve all F2L pairs.
• BeltFOP: Try to solve 1/4 cross and solve equator edges at the same time with less moves as much as you can. If it is too hard, just only solve 3/4 equator or 2/4 whichever is easier and faster. Then do F2L. (If you can get all equator edges solved, you are able to do ZZF2L)
• Roux Block: Make a 1x2x3 Block (If u can find an F2L pair.)

(8)If there are no edges to do cross easily, (you're lying, jk)you can do:

• Advance RouxVH: Solve a cross with all 4 edges unoriented.
• Columns First (FCOP): Solve all F2L pairs first, orient and permute corners (CMLL is optional), then L8E or DLSE (double LSE) to orient and permute all edges.

---

2. F2L Stage

If you are on (1), you can do F2L, PF2L (Protecting F2L or beginner Multislot), or Lazy F2L(or Fake F2L) (insert F2L pair that has unoriented edges, corner, or both).

If you are on (2), you can do same process from the previous step.

If you are on (3), you can do same process from the previous step.

If you are on (4), you can do same process from the previous step.

If you are on (5), you can do:

• Blockbuild or Petrus F2L: If you have 2x2 block, form a 2x2x3 block, and then 3x3x2 or whole F2L pair solved.
• F2L, PF2L, or Lazy F2L

If you are on (6), you can do:

• Roux F2L: Solve F2L Roux Style or CFOP style (whichever your comfortable with). After that, you can do CMLL or just solve cross and do OLL and PLL.
• Advance Blockbuilding: Make 1x2x3 Block on each empty side, (ZZF2L but with non EO edges)
• F2L, PF2L, or Lazy F2L

If you are on (7), you can do:

• Roux F2L, F2L, PF2L, or Lazy F2L
• BeltFOP---->ZZF2L
• Petrus F2L

If you are on (8), there is no need for this step.

---

3. Last Layer

There are a lot of ways to do last layer. All this is optional. You can use (If you have all cross and F2L solved):

• Easy COLL
• Easy ELL
• OLL
• PLL
• SLL (Special Last Layer): Easy ZBLL Easy 1LLL
• BLL (Blocking Last Layer)
• L3C
• RLL (Rotate Last Layer or Easy Pure OLL)

If you have (3) on cross, you do:

• RouxVH: If you have one unoriented edge on your cross with all F2L pairs solved, execute RouxVH, then use OCLL, then PLL.
• Hawaiian Koceimba: If you have a random oriented edge in your cross, you can do OLL regularly with the cross edge. If you have a random unoriented edge in your cross, you must Roux insert the last cross edge into the cross, then do OLL and PLL.

If you have (5) on cross, you do:

• Advanced RouxVH: If you have unoriented edges on your cross with all F2L pairs solved, execute RouxVH, then use OCLL, then PLL.
• MCross: If you have all F2L edges but 2 cross edges are misplaced adjacent swap, you use (M' U2 M) to take out the edge and put it in correct place. Then do OLL and PLL.

If you have (6) on cross, you do: Advanced RouxVH or MCross

If you have (7) on cross, you do: Advanced RouxVH or MCross

If you have (8) on cross, you do: DLSE or RouxOP (solve cross and then OLL and PLL)

---

4. Last Slot

You can also use last slot subsets to speedsolve.

If you have:

Regular F2L pair: Easy VLS, Easy ZBLS, VHLS, WV, or Lazy VLS

Fake Petrus: Easy MGLS, Lazy MGLS

BeltFOP: Easy CLS, Lazy CLS, Easy ZZ-CT, Lazy ZZ-CT or Fake-CT

Methods to Learn First before Lazy CFOP

There are some methods you must learn and understand about its concept in order for you to learn Lazy CFOP.

The most important methods to learn and understand:

-CFOP

-Roux

-Petrus

-FreeFOP

The least important methods and subsets to understand:

-ZZF2L

-Hawaiian Koceimba

-Columns First

-MGLS

-VLS

-ZZ-CT

Lazy CFOP Laws

-Effiency does not matter, what matter is that it's easier and faster.

-Only easy algorithms can be allowed in Lazy CFOP, if a hard algorithm is easier for you, then you can use hard algs only if you are comfortable with it.

-Lookahead is not require to learn in Lazy CFOP, but needs fast recognition to be Sub 20, if added lookahead, high chance you may be sub 15 or 10 depending on how good your lookahead is.

-E, E', z, z', B, B', d, d', u, and u' are a little banned notations due to confusion move. If an alg has these move notations, it is a hard alg, unless you are comfortable with, that is fine.

-This method is recommended only for beginner and beginner CFOP cubers. Advance cubers are highly not recommended, but they can learn this method, but may be risky.

-Intuition is only use for expert cubers who wants to learn Lazy CFOP. Intuition is not allowed for beginner cubers because intuition takes thinking process which makes beginners to solve slower. With algs, beginners can execute algorithms automatically and without thinking (muscle memory).

-You can use this method in any style you want, the steps just give options, whatevers comfortable for you.

Lazy CFOP PLL Terms

A(a) = Forward A-Perm

A(b) = Backward A-Perm

U(a) = Right turn U-Perm

U(b) = Left turn U-Perm

J(a) = Lefty J-Perm

J(b) = Righty J-Perm

R(a) = Lefty R-Perm

R(b) = Righty R-Perm

N(a) = Lefty N-Perm

N(b) = Righty N-Perm

G(a) = Lefty Pretty G-Perm

G(b) = Lefty Ugly G-Perm

G(c) = Righty Pretty G-Perm

G(d) = Righty Ugly G-Perm

Lazy CFOP Tricks

• RouxVH - A subset to orient one cross edge and last layer edges at once.
• Advanced RouxVH - A subset to orient more than one cross edge and last layer edges at once.
• MCross - A subset to permute edges in right place on bottom cross.
• MF2L - A subset to fix the F2L pairs in the correct place.
• Lazy Petrus - A subset to make a 2x2x1 Block with 2 cross edges solved.
• Lazy Cross - A subset to solve 3/4, 2/4, or 1/4 cross, then solve all F2L pairs, when doing F2L pairs, you can sometimes do Roux style using less moves. Then solve or insert the remaining cross edges into the bottom cross.
• Fake Petrus - A subset to solve a 2x2 block unoriented. Then solve all 3 F2L pairs. Then you can fix the unoriented F2L or use it to skip OLL like MGLS, ELS, or Lazy VLS.
• Galaxy Cross -Invented by Trent C., a subset to make two 2x2x1 blocks across from each other making a spiral shape.
• BeltFOP - A subset to try making a multiple D-Cross or solve the bottom cross and equator edges at the same time as far as you can. If succeeded, you can do ZZF2L.
• DLSE - A beginner way of L8E (last eight edges). The first way is to solve 2 cross edges oppositely or across from each other, and then LSE. The second way is to do L4E and then cube rotate y or y' to do another L4E.
• PF2L - A beginner way to multislot. You put the F2L pair at the preserve spot to make another F2L pair or insert F2L pair. File:Pf2l.jpg
• Lazy F2L - Inserting F2L pairs unoriented. Then orient F2L pairs correctly. You can also use those F2L pairs to OLL skip.
• Lazy VLS - A subset to OLL skip by using Edge Partial Control, then WV or lazy WV(keep doing sexy until you get an easy WV case). File:Lazy vls.jpg
• Lazy MGLS - A subset to make the unoriented corner from F2L pair on top by using triple sledgehammer, then orient all last layer corners except the F2L corner, then use 2 cases of CLS to insert the F2L corner into the F2L pair correctly and OLL skip. File:Lazy mgls.jpg
• Lazy CLS - Orient all last layer corners except F2L corner. Then use 2 cases to insert the F2L corner in F2L pair resulting an OLL skip. File:Lazy cls.jpg
• Lazy ZZ-CT - If a random corner in the first layer is oriented, do OLL with F2L corner on last layer (orienting everything), then permute the LL corners including the F2L corner into a diagonal swap. Then line up the F2L corner with the random corner in first layer, then do triple sledgehammer to get EPLL. File:Lazy zz-ct.jpg

Pros

• Beginnerly Fast - Lazy CFOP requires easy algs only. Those easy algs are tricks to help boost beginner cubers into fast times.

• All Easy Algorithms - Lazy CFOP uses a lot of algorithms, but they are easy to learn and memorize. This is only because Lazy CFOP uses terminology algorithms mashed up together. (For example: OLL: (R U R' U)(Sledgehammer(R F R' F')(U2)(Sledgehammer))

• Comfortablilty - Lazy CFOP makes beginner cubers to get faster very easily. With the algs only used by termimology moves, it is more comfortable. Plus, they do not need lookahead, so this makes it easier for beginners to use.

• Good Inspection - Lazy CFOP is very good at using inspection time. With scramble cases, using Lazy CFOP uses less thinking and easier to plan ahead by deciding which method to use first.

• Beginner Shortcuts - Easy shortcuts means easy way to get faster. Lazy CFOP tricks are basically beginner types of advance subsets. Those tricks are easy to perform. When performing a Lazy CFOP trick, you can sometimes skip a step and solve pieces that are in wrong place.

• Add in advanced - If added advanced subsets or tools like lookahead, full COLL, and etc., using Lazy CFOP will be way faster. (Only recommended for advanced and professional cubers)

Cons

• Efficiency - Lazy CFOP uses a ton of moves. Since it uses terminology algs, this will make more moves when performing it. More than a hundred moves are used in Lazy CFOP solves. But to advanced cubers, their style will make the method efficient. (But too hard for beginners to use.)

• Number of Algs - Lazy CFOP uses over 100 algs. This is because Lazy CFOP does not use intuition. They use algorithms because it performs without thinking, making it faster and easier for beginner cubers.

• Failed Outcome - Sometimes, when performing a Lazy CFOP trick, one mistake can end your times really bad. This mistake can be caused by recognition fail, performance fail, and setup fail.