# How to Learn an Algorithm Set



## lerenard (Jan 5, 2015)

This information may not be helpful to a lot of people, but it might help some, so I decided to write up how I learn algorithms. In the past two weeks I have learned full COLL and Winter Variation and Summer Variation (a total of 40 + 27 + 27 = 94 algorithms), so I think I am at least not a noob on this topic. I have also learned full PLL in 24 hours, and although I don't know full OLL, that's by choice.

Step 1: Get a list of the algorithms you want to learn.

This shouldn't be too hard. If you are having trouble, try using this website.

Step 2: Print it off and analyze it.

Before you start trying to get even one algorithm into muscle memory, take a look at all of them and try to find patterns in both individual algorithms and between them. To find patterns within an algorithm, look for sequences that repeat, or that undo themselves. For example:
F U' r' F R2 F' r U R2 F'
can be analyzed as 
F // setup
U' r' F // A
R2 // B
F' r U // A'
R2' // B'
F' // undo setup
So instead of remembering 10 moves, I just remember <F;[A;R2]>, and the 3-move identity of A.

Perform each algorithm on a solved cube. If it does _not_ create the situation that algorithm is supposed to solve (henceforth known as A), you know that the inverse of that algorithm solves the case you now have in front of you (A'). Check out A' on your alg sheet and perform that algorithm on a solved cube. You should get A. Now compare both algorithms and see if they actually are inverses. If they aren't, determine which one is easier to perform, and then use the inverse of that to solve the other case. To do the inverse, do the opposite of all moves backwards. (R U R' U R U2 R' becomes R U2 R' U' R U' R'). In this way you only have to remember one algorithm instead of two. More on this later.
One other trick you can try is to mirror the algorithm. This means that all moves from the previous algorithm become prime, and L and R are swapped. (R U R' U R U2 R' becomes L' U' L U' L' U2 L) Once you get the hang of it, it's easy to read an algorithm and just do the mirror. Sometimes the mirror of A (henceforth known as B) still solves A but from a different angle, this is still helpful because it can prevent you from needing to do a U2 in some cases. If you do B on a solved cube and you don't get A', you know that A and B solve different cases. In order to find what case B solves, do B' on a solved cube. Check that case on you alg sheet, and if it isn't the mirror of A, cross it off and replace it with that. You can now treat B like its own algorithm and check its inverse as above.

Using this system of reduction, I was able to turn the 40 COLL algorithms into 16 I didn't already know.

A Leman used a mnemonic naming system to memorize full ZZLL in a month. You can learn more about how he did it here: https://www.speedsolving.com/forum/showthread.php?50140-Mnemonic-System-for-Naming-ZZLL-Cases 

Step 3: Visual Memory
Once you have done this with all the algorithms and reduced them to their mirrors and inverses (hopefully with notes saying _which_ algorithm it's the inverse/mirror of) and you have analyzed each algorithm individually for patterns, you can start getting the algorithm into visual memory. This means you can perform the algorithm without reading but you still need to look at the cube. I find it helpful to perform it slowly while reading it and watch where the pieces go. Tracking F2L pairs is especially beneficial. For example, in R U R' U R U2 R', I would note that the F2L pair in FR is extracted, then slowly pushed clockwise, and then brought back into place with a U2. Then once you have watched the algorithm enough times you can try to do it without reading. From here you should find it easy to perform the mirror and inverse algorithms.

Once you can perform an algorithm comfortably without looking, move on to the next one. Which one is the "next" one? Well, if you are doing something like full OLL or ZBLL or anything with a lot of algorithms, you should break it up into chunks. For COLL, I based it on corner orientation (First I did the Double Sune cases, then Pi, etc.) For OLL, you might base a group around algorithms that use a trigger (this is especially easy because within a group you only need to remember the different moves around the trigger, not so much the trigger itself). So basically you want to be able to do all the algorithms in a certain group (preferably containing around 8 algorithms) without looking before moving on to the next step. 

Step 4: Recognizing
Once you have a group "learned" you need to learn to recognize when to use it. I have found that the easiest way to do this is to order the algorithms and practice doing them in the same order, and separately learning the cases in order. Usually you can find a logical way to order the cases, and mentally it's easy to perform a series of algorithms in the same order every time. I realize this isn't practical with all algorithm sets, but it is a good place to start from. Another (obvious) way to memorize which case goes with which algorithm is simply to create the case, identify it and what separates it from other cases in the same group (i.e., this is a G-perm and not a Y-perm because both outer corners are the same color) and then perform it. My gut feeling is that this method of memorization isn't as efficient, especially with large algorithm sets.
You should be able to recognize and perform all the algorithms in a group before moving on to the next set. I find that memorizing them in groups like this is more helpful than memorizing one at a time because if you can see that it is in the group quickly (this depends on how you made your group) you know that you have the algorithm for it and don't have to spend too much time determining whether or not you even know the algorithm.

Step 5: Practicing
Once you can recognize and perform one group, go ahead and do some solves (preferably untimed) If you don't run into a case from your group, try to create one (inserting the last F2L pair differently is usually the most helpful tool here.) This will test whether or not you can actually recognize the case during an actual solve. You can also try to reduce the set you'll get. For example, if you've learned 2GLL, you can practice with 2-gen scrambles or if you've learned Diag CP COLLs, do a Y-perm before 2-gen scrambles (credit: Bindedsa for the idea). I will recommend that until you feel very confident in your ability to recognize the full group, you make a decision before doing timed solves to simply ignore that group and use another way to solve it. This prevents you from wasting time racking your brain when you are being timed. I would also recommend running through the whole group at least twice a day (once in the morning and once at night) and at any point if you can't remember or recognize an alg during a solve. Eventually the algorithms will migrate to your muscle memory, and you'll find that you can perform them blindfolded. This is helpful because it means you can do them faster and you can look ahead to other parts of the cube while you are performing the algorithm. You can also speed up this process by drilling the same algorithm over and over, but I find this unnecessary.

Once you have a group confidently memorized and you can use it during solves, move on to the next group (start at Step 3). I get a bit obsessive when I'm memorizing algs and I often work on multiple groups simultaneously (being at different stages with each group) but this isn't necessary and I realize most people don't have as much time as I do for cubing.

Step 6: ???

Step 7: profit.

I hope this helped someone. If you feel I should add or change something or if you just think I totally screwed up, let me know.


----------



## Bindedsa (Jan 5, 2015)

Pretty good. I usually like to learn algorithms slowly, but only because when I learn them too fast I mix up cases and forget them. Learning different sets might help, as you won't get them mixed up as much. I think the analyzation should go after learning. It's a lot easier to look at mirrors and inverses after your comfortable with an alg. Also, I would add looking for patterns to learning, EG. for R U' R' U2 R U R' U2 R U R' U R U' R', notice how U2 R U R' repeats, this is also a nice example because if you remember that, you only have to track pairs for the rest of it. One last thing, for practicing its useful to try to reduce the set you'll get, for example if you've learned 2GLL, practice with 2gen scrambles or if you've learned Diag CP COLLs do a yperm before 2gen scrambles.


----------



## TDM (Jan 5, 2015)

Bindedsa said:


> I usually like to learn algorithms slowly, but only because when I learn them too fast I mix up cases and forget them.


:confused:




lerenard said:


> This makes performing the inverse and mirrors a lot easier than memory methods that revolve around muscle memory because you are basing your memorization on what it looks like, not what it feels like.


Yes, but sometimes inverses/mirrors do feel similar. Also, you want to eventually be able to learn all your algs by muscle memory, even if you don't learn them like that.

Are you thinking of learning full ZZLL/ZBLL? One ZZLL set (set = for each COLL, not OCLL) is only four algs, and one ZBLL set is 12.


----------



## Bindedsa (Jan 5, 2015)

TDM said:


> :confused:



What's confusing? I just stay consistent, it's not like I've ever learned nearly 100 algs in two weeks, like the OP.


----------



## TDM (Jan 5, 2015)

Bindedsa said:


> What's confusing? I just stay consistent, it's not like I've ever learned nearly 100 algs in two weeks, like the OP.


You don't learn algs "slowly" compared to most other people


----------



## lerenard (Jan 5, 2015)

Bindedsa said:


> Pretty good. I usually like to learn algorithms slowly, but only because when I learn them too fast I mix up cases and forget them. Learning different sets might help, as you won't get them mixed up as much. I think the analyzation should go after learning. It's a lot easier to look at mirrors and inverses after your comfortable with an alg. Also, I would add looking for patterns to learning, EG. for R U' R' U2 R U R' U2 R U R' U R U' R', notice how U2 R U R' repeats, this is also a nice example because if you remember that, you only have to track pairs for the rest of it. One last thing, for practicing its useful to try to reduce the set you'll get, for example if you've learned 2GLL, practice with 2gen scrambles or if you've learned Diag CP COLLs do a yperm before 2gen scrambles.



I added your idea about using special scrambles. I understand why you would analyze after learning the algs, but I really feel like (for me, at least) it is just so much easier to remember an algorithm that I have reduced to a more basic sequence of moves, and I don't want to memorize one algorithm only to find later that I should have memorized the inverse of another because that was easier, or something like that. For this reason, I suggest looking for mirrors and inverses before you devote time to analyzing anything else.

@TDM: I made the guide less negative toward muscle memory, because it does help you to do the algorithm _fast_, but I still feel that if you want to remember a lot of algs you need to let muscle memory happen on its own over time. 
ATM I have no desire to learn 167 last layer cases with 80 algs, I'm still working on differentiating between my SV cases and then I want to focus more on lookahead/efficiency/etc. Moreover, I feel that knowing both SV and WV and my edge control methods it would only be useful around 25-33% of solves, which doesn't really seem worth it.


----------



## Bindedsa (Jan 5, 2015)

lerenard said:


> I don't want to memorize one algorithm only to find later that I should have memorized the inverse of another because that was easier, or something like that.



I took the opposite approach to ZBLL, my first priority was to have an alg for every case, then I worried about where or not that alg was best for that case. I know others don't like this as they feel like it wastes time, but I wanted to get used to recognizing all cases.


----------



## A Leman (Jan 6, 2015)

I learned full ZZLL by associating every case to a name to help memorization. 

The steps I went by were
1. decide on a good recognition method
2. make a code to translate a zzll case into a mnemonic word. That's always going to be the algs' name.
3. Start practicing the cases I already knew and associating the alg to the name. 
4. Memorize the cases with a mix of mnemonics and the standard approach.For example, I gave some common triggers names/images and linked them to the cases names. I also made a journey where I linked inverses to each other like images for bld. 
5. practice until the mnemonics are unnecessary.

This took about a month in total. I still know the cases and now I use ZZLL as my last layer method. Another benefit of the naming system is that it's very easy for me to go through all of the cases in order for time attacks like what I do with 3style cases.

https://www.speedsolving.com/forum/showthread.php?50140-Mnemonic-System-for-Naming-ZZLL-Cases
As a side note/warning, you will forget some of the WV,SV,COLL that you've crammed in the last 2 weeks if you don't use them regularly, It seems like it takes a long time to go from knowing the case to not being able to possibly forget the case if you decide to stop cubing for a long time.


----------



## supercavitation (Jan 6, 2015)

A Leman said:


> As a side note/warning, you will forget some of the WV,SV,COLL that you've crammed in the last 2 weeks if you don't use them regularly, It seems like it takes a long time to go from knowing the case to not being able to possibly forget the case if you decide to stop cubing for a long time.



As someone who learned full OLL in 18 hours, then had to go back and reassociate all of the algs and cases in my head after I lost them, I can confirm both that the method given by the OP works, and that it fails if overused, in the way you described.


----------



## lerenard (Jan 6, 2015)

supercavitation said:


> As someone who learned full OLL in 18 hours, then had to go back and reassociate all of the algs and cases in my head after I lost them, I can confirm both that the method given by the OP works, and that it fails if overused, in the way you described.



Was this you? https://www.youtube.com/watch?v=WXSs2wRC7KE

I watched that recently.

I feel like learning 50 algs in 18 hours is a lot more intensive than 94 algs in 2 weeks. I recognize the possibility of losing the algs, but I don't really feel like I'm done learning them. I use COLL in speedsolves and feel like my recognition speed is about as fast as my PLL recognition and even faster for those annoying cases like this and this
As far as WV and SV, I am still in the process of solidifying case recognition into my memory and so I'm doing a lot of deliberate practice with them. Regardless, I think they are useful algs that I will have reason to utilize, so I'm not too worried.

@ A Leman, full ZZLL in a month is very impressive, I will link to your post in the OP.


----------



## supercavitation (Jan 6, 2015)

lerenard said:


> Was this you? https://www.youtube.com/watch?v=WXSs2wRC7KE
> 
> I watched that recently.
> 
> ...



Nope, I got the idea from that video.


----------



## lerenard (Jan 6, 2015)

So do you feel like it would have been better to spread it out and possibly learn them in smaller chunks? In the video he mentioned he had a horrible headache and case recognition became ridiculous.


----------



## supercavitation (Jan 6, 2015)

lerenard said:


> So do you feel like it would have been better to spread it out and possibly learn them in smaller chunks? In the video he mentioned he had a horrible headache and case recognition became ridiculous.



I didn't get any headaches, but when I went back through it, I learned it much more effectively going a bit slower (took me a few weeks to finish it). When I want to maintain all of the algorithms indefinitely, I tend to max out at about 5 algorithms per day. I have successfully done more, but mostly in rare cases when I got two algs that were really similar or I had an obscenely long time to spend on them (learned 9 OLLs in a 4 hour flight, because I had nothing else to do). I'd say I'm much better with the algorithms, and my recognition times drop significantly when I spread them out and learn them in smaller chunks.


----------



## AlphaSheep (Jan 6, 2015)

The bit where you learn a case together with it's inverse, mirror and inverse of the mirror is really useful. I've been doing this while learning COLL, and it's like getting four algs for only a little more than the price of one. The only tricky bit is that I tend to confuse the case recognition when I learn more than one case at a time. 

The worst are  and .


----------



## Puggins (Feb 27, 2015)

I know this is kind of old, but where did you learn your algorithms from?


----------



## michaelcmelton (Mar 17, 2015)

the wiki database is a good place to pick up algs and algdb.net is another one.


----------



## TMarshall (Mar 18, 2015)

Anyone know a place with good summer variation algs? I'm probably gonna learn this after wvls, but the only place i found algs is on the wiki, but some of the algs don't seem too great. Or should I just generate my own algs?


----------



## Berd (Mar 18, 2015)

TMarshall said:


> Anyone know a place with good summer variation algs? I'm probably gonna learn this after wvls, but the only place i found algs is on the wiki, but some of the algs don't seem too great. Or should I just generate my own algs?


Algdb.net


----------



## obelisk477 (Mar 18, 2015)

TMarshall said:


> Anyone know a place with good summer variation algs? I'm probably gonna learn this after wvls, but the only place i found algs is on the wiki, but some of the algs don't seem too great. Or should I just generate my own algs?



Here's some I generated in like an hour. There are better cases for some, but it can get you started:

https://drive.google.com/open?id=0ByB0GclBx3DyRmEzSU1jQzZRVW8&authuser=0


----------



## TMarshall (Mar 18, 2015)

Wow thanks! those are really nice. Also, random thing, but I still find it amazing that even really fast people don't know the first case.(Jay Mcneil didn't use it in his walkthrough solves) I played around with some WV cases and found that pretty quickly.


----------



## RaZoR777 (Jun 1, 2015)

Thanks,with this I started learning VHLS and know 23 algs in 2 days


----------



## OLLiver (Jun 1, 2015)

RaZoR777 said:


> Thanks,with this I started learning VHLS and know 23 algs in 2 days



Yeah its really good isn't it? I managed to do 20 algs yesterday with this


----------



## josh42732 (Jun 1, 2015)

Wow I'm slow compared to you guys. I just learn an OLL that has really been bothering that I don't know, that I tend to get a lot and takes 2-look to solve it, and learn it. I drill the alg over and over until it is in muscle memory, then do it a couple times without the sheet and then I don't usually learn it or confirm that I have learned it until I get it in a solve. I have learned 28/57 using this method and my slowest are just the lefties which are not that slow. I really like this method because I am not just learning random algs that I don't have any connection to, but because it is an annoying case that I learn, I am connected to it somehow, and I learn to do the alg fast. I have learned a max of 1 OLL a day using this method and have learned no more than 3 a week just so I know that I know them fully. lol

I also do this for learning alternative PLL's.


----------

