#### Athefre

##### Member

- Joined
- Jul 25, 2006

- Messages
- 1,184

CLL+1

COLL+1

Around 10 years ago Thom Barlow (Kirjava) was talking about a new LL method. The idea is to solve CLL and a single edge in one algorithm. The second step would then just be an edge 3-cycle. For cross->F2l this means all that’s left is L3E. For ZZ or Petrus, this means all that’s left is a U-Perm. The problem was that a system hadn’t been fully developed to make it work. In July I thought of how to solve the problem and discussed it on the Roux Discord server. It turned out that TDM had similar ideas a few years ago. We discussed it for a while then I started development.

The way this LL method works is that there are four algs per CLL case when edges aren’t oriented (for when doing cross then F2L for example). The four algs are split into two sets. One set cycles the edges a certain way and the other set cycles them in a different way. Then, within each of these two-alg sets, one alg orients edges a certain way and the other alg orients the edges the opposite way. When all edges are oriented, such as in ZZ or Petrus, there are two algs per CLL case. One alg cycles edges a certain way and the other alg cycles them a different way. In total there are 166 cases for CLL+1 and 83 for COLL+1.

When edges aren’t oriented, you recognize the CLL case and the edge case for that CLL. You will memorize for each case which edge will be moved to the solved position. In the document linked at the top of this post, each case in the images has a number on it. Below those images will be two columns showing “Cycle 1” and “Cycle 2”. Locate your number below one of those columns. Each number shows which edge will be moved to the solved position when one of the algs above the number list is performed. To the left of each algorithm is an image that shows how the alg will flip all of the edges. During a solve, you note the orientation of the edge associated with the number and perform the algorithm that solves that case while also flipping that edge if necessary or keeping its orientation if it is already oriented. When all edges are oriented, you simply locate your number and perform the alg that solves the case. The all edges oriented version is also linked in this post as COLL+1.

This LL method makes for a great alternative. It works for when LL edges are either misoriented or oriented. It isn’t a huge number of algorithms compared to ZBLL and it provides the solver with a very short and easy second step compared to PLL. One major benefit is the high chance of skipping the second step. For Cross->F2L->CLL+1, there are only 10 L3E cases so skips will be pretty frequent. For ZZ, Petrus, and other methods which lead to an EO LL, there are only two L3E cases and those are the simple U-Perms. As for negatives, recognition for the first step takes longer than OLL because you are mostly recognizing the LL case. However, this is made up for by three additional advantages. The first is the short L3E cases. There are fewer long and or bad cases compared to PLL. The worst L3E cases are the 2-flip cases, of which there are two. The rest are either 7 or 9 moves each. The 2-flips can even be easily avoided by just using a different alg and more on that is described in the notes section below. The second advantage over PLL is the fact that L3E skips are more frequent than PLL skips. A final advantage over PLL is that, eventually, the L3E step takes zero recognition time. Because the solver is recognizing the edge case, they will eventually come to know exactly what L3E case will come after performing the CLL+1 alg. This means a perfect transition from CLL+1 to L3E.

Spoiler: Notes

Spoiler: History

Development File: CLL+1 Unions

Development File: CLL+1 System

COLL+1

Around 10 years ago Thom Barlow (Kirjava) was talking about a new LL method. The idea is to solve CLL and a single edge in one algorithm. The second step would then just be an edge 3-cycle. For cross->F2l this means all that’s left is L3E. For ZZ or Petrus, this means all that’s left is a U-Perm. The problem was that a system hadn’t been fully developed to make it work. In July I thought of how to solve the problem and discussed it on the Roux Discord server. It turned out that TDM had similar ideas a few years ago. We discussed it for a while then I started development.

The way this LL method works is that there are four algs per CLL case when edges aren’t oriented (for when doing cross then F2L for example). The four algs are split into two sets. One set cycles the edges a certain way and the other set cycles them in a different way. Then, within each of these two-alg sets, one alg orients edges a certain way and the other alg orients the edges the opposite way. When all edges are oriented, such as in ZZ or Petrus, there are two algs per CLL case. One alg cycles edges a certain way and the other alg cycles them a different way. In total there are 166 cases for CLL+1 and 83 for COLL+1.

When edges aren’t oriented, you recognize the CLL case and the edge case for that CLL. You will memorize for each case which edge will be moved to the solved position. In the document linked at the top of this post, each case in the images has a number on it. Below those images will be two columns showing “Cycle 1” and “Cycle 2”. Locate your number below one of those columns. Each number shows which edge will be moved to the solved position when one of the algs above the number list is performed. To the left of each algorithm is an image that shows how the alg will flip all of the edges. During a solve, you note the orientation of the edge associated with the number and perform the algorithm that solves that case while also flipping that edge if necessary or keeping its orientation if it is already oriented. When all edges are oriented, you simply locate your number and perform the alg that solves the case. The all edges oriented version is also linked in this post as COLL+1.

This LL method makes for a great alternative. It works for when LL edges are either misoriented or oriented. It isn’t a huge number of algorithms compared to ZBLL and it provides the solver with a very short and easy second step compared to PLL. One major benefit is the high chance of skipping the second step. For Cross->F2L->CLL+1, there are only 10 L3E cases so skips will be pretty frequent. For ZZ, Petrus, and other methods which lead to an EO LL, there are only two L3E cases and those are the simple U-Perms. As for negatives, recognition for the first step takes longer than OLL because you are mostly recognizing the LL case. However, this is made up for by three additional advantages. The first is the short L3E cases. There are fewer long and or bad cases compared to PLL. The worst L3E cases are the 2-flip cases, of which there are two. The rest are either 7 or 9 moves each. The 2-flips can even be easily avoided by just using a different alg and more on that is described in the notes section below. The second advantage over PLL is the fact that L3E skips are more frequent than PLL skips. A final advantage over PLL is that, eventually, the L3E step takes zero recognition time. Because the solver is recognizing the edge case, they will eventually come to know exactly what L3E case will come after performing the CLL+1 alg. This means a perfect transition from CLL+1 to L3E.

- Recognition is about the same as ZBLL. It actually becomes a little easier than that. This is because for each CLL+1 case, one alg solves 9/12 edge permutations and the other alg solves the other 3/12. So all the user is looking for is if the LL case is one of those 3/12 cases or not. If it isn’t, then they know to just use the other alg. This mostly applies to COLL+1. For CLL+1 that doesn’t always work because you need to check the edge that is going to be solved to see if you need to flip or preserve its orientation. Another way to recognize is to determine whether the edges are phased or unphased. This works for COLL+1 if you don’t care about knowing exactly which U-Perm will occur. However, for CLL+1 this recognition is difficult because you have to think during the recognition time about what kind of cycle your alg does to the edges to determine which edge will be moved to the solved position. You need to know which edge is being moved to the solved position so that you can choose the correct alg that either flips or preserves the orientation of that edge. I’m actually not completely sure about the phased/unphased recognition being effective for COLL+1 either. In the analysis that I’ve done, it seems that it doesn’t always work. For some cases, the phased edges alg would be required to be used on an unphased edges state. Also, thinking about it in this phased/unphased way doesn’t reveal what cases each alg is actually able to solve. An alg may be good for when edges are phased, but you wouldn’t know that you could instead use the other alg in the set. This other alg may be one that you greatly prefer.
- There are patterns within the cases, so that means memorization will be easier than it first appears. Many cases contain the exact same list of numbers and the edges that are moved to the solved position are the same. I based the edge positions around the corners on the ZBLL sets on the wiki. If the edge positions were further made equivalent among all of the CLL cases, there would be even more patterns to make memorization easier.
- In a set of algs, there is an overlap where both will solve many of the same cases from the list of 12. This means you can choose which alg you want to use. You can use the alg you like more and avoid the one you like less. Another important thing to note is that of course in 2/12 cases, one of the algs will correctly position all of the edges. For CLL+1 this means you can foresee the LL being completely solved and proceed that way. Or, once you are familiar with the cases, you can sometimes use the alg from the other set to force an L3E case that you prefer. Even though there are only a few L3E cases and each are short and good algs, this could provide an additional advantage. You’ll be able to see that using one alg will lead to a 2-flip, so you can use a different alg to avoid the 2-flip and have a more desirable L3E case.
- You can learn another set of algs or use a different combination to further increase the chance of an L3E skip. You know how your alg cycles the edges and the L3E case it will lead to. For some cases you can use a new alg from a third set to cycle a different way – forcing an L3E skip or an L3E case you prefer.
- If the corners are already solved, it is best to use ELL. For COLL+1, if the corners are oriented, it is best to use PLL. If using a method that gets to LL without intentionally orienting edges, but all LL edges happen to be oriented, the CLL+1 sets of algs may not contain two algs that preserve the orientation of all edges. So you have a choice of using CLL+1 and leading to L3E or learning another alg set (from COLL+1) to preserve the EO and lead to a U-Perm.
- The diagonal O case only requires one type of cycle to solve an edge for each of the five possible edge permutations. This means another alg combination isn’t necessary. So for CLL+1, only two algs are needed and for COLL+1 only one alg is required. This works for two of the possible ways of cycling edges (either swapping UB+UL or UB+UR in my document and using my AUF alignment). If the diagonal swap alg cycles edges in ways different from those two, then an alg combination is required.
- I have attached the Excel files that I created for this method. They contain all of the possible unions of cycles (the possible alg type combinations) that will solve a corner case and an edge. I am providing this to help users generate their own algs. So far I have only a few alg sets generated for each CLL case. The ultimate goal is to have an alg set generated for every cycle. There is also an alternate way of looking at how corners are swapped and edges cycled. An adjacent swap corner case can also be viewed as a cycle of three corners. This would accomplish the same result of solving the corners. Viewing it as a cycle of three corners means that you have to also view the edge cycle in an alternate way. With a corner adjacent swap, you can’t perform a 3-cycle of edges. But if you view that corner case as a 3-cycle of corners, then you can perform a 3-cycle of edges. This alternate way of thinking about cases didn’t prove to be of any use for CLL+1. I’m only providing this explanation in case someone considers this alternate view and questions the benefits. There could be an advantage that I didn’t see, so if anyone wants the analysis of this alternate view I did generate that also and can provide it.
- You may eventually ask yourself if it’s possible to add a third alg into the union for COLL+1 and solve all edges using just 120 algs. I did update my predictor to test this. It turns out that it is possible…if the edges are in an illegal state. Meaning if you take out two edges and put them back in the wrong positions. So maybe there is a method that could take advantage of this property. Such as having two edges at DF+DB swapped; causing the LL edges to be in that illegal state.
- Additional Tricks: Can use transformation tricks to further reduce the number of cases, avoid cases you don’t like, or force an L3E skip. R or L moves can position a pre-made pair and change the LL to a different case. M moves can move edges into a more advantageous position. This hasn’t been explored yet, so the beneficial uses need to be documented.

Around 2011 is when this LL idea was first being talked about. It may have been an idea from Thom Barlow (Kirjava) or he had seen the idea somewhere else. He was sometimes talking about an LL method he was calling CLL+1 and making example solves. The problem was that he didn’t have a system for how to make it work. So he was asking here on the forum if anyone had ideas. I suggested a couple of systems that would work, but they weren’t perfect. The idea eventually kind of went away. A few years later, some users discussed the idea of using two COLLs per case for ZZ and taking advantage of the phased/unphased edges state to force a U-Perm. That was essentially COLL+1. Then TDM had the idea of being able to extend it to an LL with misoriented edges by having one algorithm with a certain edge orientation and another algorithm with the reverted orientation. This made it become the original CLL+1 idea.

In July of this year, unaware of those posts, I had the same ideas myself. Except, instead of the phased/unphased edges idea that others were thinking, I discovered a new kind of system where two or more algorithms can be combined like a Venn diagram. For CLL+1 this means that one algorithm does one type of edge cycle and the other algorithm does a different edge cycle. These two cycles overlap to solve an edge in all cases. The system is called the Cycle Union System and you can learn more about it here. It has many applications beyond CLL+1.

In July of this year, unaware of those posts, I had the same ideas myself. Except, instead of the phased/unphased edges idea that others were thinking, I discovered a new kind of system where two or more algorithms can be combined like a Venn diagram. For CLL+1 this means that one algorithm does one type of edge cycle and the other algorithm does a different edge cycle. These two cycles overlap to solve an edge in all cases. The system is called the Cycle Union System and you can learn more about it here. It has many applications beyond CLL+1.

Development File: CLL+1 Unions

Development File: CLL+1 System

**Alg sources:**- CubeExplorer – Most algs were found here.
- The most popular Roux 2H alg sheet: https://docs.google.com/spreadsheet...1yzTjnqSMS3D3dZcsCIOiJqcI/edit#gid=1701452193
- Algdb.net
- SpeedSolving Wiki
- TDM – The four algs for the adjacent swap O case were provided by TDM. Also, TDM has found good CMLL algs over the years and they are within the CMLL document in the link above. Some of them proved to be helpful in developing CLL+1.

Last edited: Nov 10, 2020