# [Help Thread]How to Get Faster Using the Petrus Method

#### 2180161

##### Member
So, as the title says, this will be guidelines on how to get faster at the Petrus method. Unfortunately the Petrus method has very low usage, but since switching to it in the past month my averages are within one second of my CFOP times. anyway, here we go!

First and foremost, the most important thing to do to improve is practice. No matter the method you are using, you need to practice. The more you practice, the faster you will be able to recognize cases, and gain a better understanding of the cube. Of course, there are better ways to practice instead of just solving over and over again. Focused practice is better than just solving, but if you are incapable of doing focused practices, then just doing solves will work, though it will be slower.

All times will be in seconds.

Step 1:
Current Average: 70-90 don't know how to solve with the Petrus Method
Goal Average: 50-60
Estimated Time to Complete: 3-5 weeks

• Learn how to solve using the Petrus method if you don't. A basic guide for the steps can be found here.
• If you don't already, get a good cube. Cubes like the Moyu GTS2, Qiyi Valk 3, and the Gans Air are the biggest three contenders for "the best cube".
• At this time in solving, you should work on being able to easily finger trick the cube, which can be done by practicing.
• Decrease the time of your last layer to around 20-25 seconds. This seems intimidating at first, but by learning the algorithms for OLL and PLL (not full) you can decrease your times a lot. All you need to solve the last layer are Sune, Aa PLL, and Ua PLL. Using this 3 algorithms can get you to a 10 second last layer if you worked very hard.
• Work on the 2x2x2 block. Attempt to be able to do it in 12 moves or less, and under 12 seconds, and solve the block so that it is on the Left, Down, and Back faces.
• Learn the basics of the edge orientation step, such as detection, and how to fix them. At this time, only worry about solving them 2 at a time.

Step 2:
Current Average: 50-60
Goal Average: 40-50
Estimated Time to Complete:2-4 weeks

• Learn 3 Look Last Layer. This is a total of 10 new algorithms. A list of theses algorithms can be found here, although for this, you can ignore the edge orientation step of the page, as your edges should already be oriented.
• The time it takes to solve your last layer should be around 10-15 seconds.
• You should be practicing being able to see the entire 2x2x2 block in inspection, and be solving the entire 3x2x2 block in under 15 seconds.
• You should work to gain a better understanding as to how edge orientation works, and be able to come up with your own solutions as to how to make bad edges good, such as doing 4 at a time in some cases instead of 2.
• Your entire First 2 Layers should be solved in under 30 seconds.
• Learn how to do intuitive block-building/F2L pairing for the final third of the F2L, still using only R and U turns.

Step 3:
Current Average: 40-50
Goal Average: 30-40
Estimated Time to Complete: 3-5 weeks

• Learn the rest of the PLL algorithms, and practice your blocks and F2L A LOT. The faster your F2L, the faster the entire solve is, since you are solving 2/3 of the cube.
• Your entire F2L should be around 25 seconds, and your last layer should be 10-12 seconds.
• Learn some more block-building techniques, such as the "roundabout" and the "swing" here.
• Learn how to look-ahead. This involves not looking at the pieces you are solving, but rather, what pieces you are going to solve next, so that you can see exactly where they will end up when you finish the current step
• Practice, Practice, Practice and keep on practicing!

Step 4:
Current Average: 30-40
Goal Average:20-30
Estimated Time to Complete: 2-6 weeks

• At this point, you should be able to solve your last layer in around 5-10 seconds, and you should be able to fairly quickly recognize your OLL's and PLL's.
• As before, learn more block-building techniques, and work on training your blocks on this website. It should be noted that this website solves the block in the Up Right Front corner of the cube, and you should be solving it in the exact opposite corner. Translate your solutions to the back of the cube, and keep practicing this until you can see the entire 2x2x2 block in inspection.
• The entire 2x2x2 block should be no more than 8 moves, and you should be able to solve it in under 7 seconds.
• Continue to work on your look-ahead, as this will drastically help keep your solves fluid, and more consistent.
• You should know how to solve your edge orientation for every case that has four bad edges, without doing it two edges at a time, and start learning how to do it six edges at a time.

Step 5:
Current Average: 20-30 seconds
Goal Average: 15-20 seconds
Estimated Time to Complete: 1-2 months

• Continue practicing blocks using the trainer linked in the previous step. You should be able to see part of your 3x2x2 block in inspection, even if it is just one edge, or just one corner.
• Be able to solve the 2x2x2 block in around 4 seconds, and expand to the 3x2x2 in a total of 6 seconds.
• Be able to complete the edge orientation in around 3 seconds
• The entire First Two Layers should be completed in around 12 seconds.
• Learn and make up your own techniques to solve the rest of the first two layers using only R and U moves after the EO 3x2x2 is solved, so long as they are efficient, or using an F move if it does not affect EO, such as F' R U R' U' R' F R.
• Your last layer should be around 3-8 seconds long, though it can always be faster.
Step 6:
Current Average: 15-20 seconds
Goal Average: 12-15 seconds
Estimated Time to Complete: 4+ months

• Continue with practicing your blocks. At this point, you should be able to solve the entire 3x2x2 block in around 13-15 moves.
• The entire F2L should be solved in around 9 or 10 seconds.
• Learn how to solve the 6 bad edge cases if you haven't, and be able to recognize and orient the edges within 2 seconds.
• Practice doing 2 gen scrambles on a timer such as cstimer.net, so as to improve your look-ahead and 2-gen TPS increased.
• Start timing your splits for the entire solve, with a time for 2x2x2, expansion to 3x2x2, EO, F2L, COLL, EPLL. The splits for this in order to be in the goal average should be 1-3-2-3/4- 3/2Note that these times are recommendations, and your last layer may be faster, which would allow for a slightly slower F2L. However, these make for a good transition to the next step.
The rest is written by Tao Yu.
Current Average: 12-15 seconds
Goal Average: 9-12
Estimated Time: I don't know

- Learn full algorithmic F2L, but make sure you know how the algorithms work, and understand the concepts explained in this video. This is important because all of these cases can come up in the 2x2x3 stage.
- Learn and understand every single case in the blockbuilding pdf below.
- Learn two sided PLL recognition, either by watching videos about it, or doing so many solves that it just comes to you naturally.
- Start using COLL in your solves, but don't use the sune cases. It's usually faster to do sune + PLL. (This may be true of some other COLL cases as well, it's best to use your own judgement).
- Learn some easy ZBLL cases (just search "easy ZBLL algorithms" on Youtube)
- Do a lot of practise, and start turing faster.

Goal Average: sub 9
Estimated time: No one knows

- Start planning out parts of the 2x2x3 step during inspection. At the very least, predict the location of one 2x2x3 edge while planning your 2x2x2.
- Learn full 2GLL

Goal Average sub 8 and beyond

- Plan out the whole 2x2x3 step in inspection if you can.
- Start learning full ZBLL using the algorithms here.This will slow down your progress at first, but it will be worth it in the end. Begin with the U, T and L sets and work your way through the 472 algorithms focusing on one COLL set at a time.
- Learning 472 algs may seem daunting at first, but you will have gotten much better at learning algs after learning 2GLL - 2GLL is already one sixth of full ZBLL. Now all it will take is a good workflow - find a rate of learning algs that works for you and stick to it. Alg trainers can be very helpful with this. http://bestsiteever.ru/zbll/ and https://tao-yu.github.io/Alg-Trainer/ are good.
- Don't learn Petrus-CT, it's worse than ZBLL.
- Work on getting your ZBLL execution faster than your COLL/EPLL times. If you don't like an alg, generate a better one yourself using cubeexplorer and algexplorer.

Thanks Tao for the help!

Resources:

Alg Trainers:
http://bestsiteever.ru/zbll/ https://tao-yu.github.io/Alg-Trainer/

Last Layer:
Algorithms:

http://lar5.com/cube/blox.html

F2L: http://algdb.net/ (Only learn ones that are 2-gen or that do not affect EO)

Last edited:

#### Tao Yu

##### Member
Nice work! I agree with everything here. I'll start work on the 9-12 and beyond sections tomorrow.

#### Draranor

I've been curious about Petrus for a while now, and am finally going to start learning it tonight, so this'll be super helpful. Thanks!

#### Hazel

What's the best LSLL method for Petrus other than ZBLL? I'm thinking of either TSLE/TTLL or CLS/PLL, thoughts? I don't want to have to learn too many algorithms.

#### xyzzy

##### Member
What's the best LSLL method for Petrus other than ZBLL? I'm thinking of either TSLE/TTLL or CLS/PLL, thoughts? I don't want to have to learn too many algorithms.
Phasing + ZZLL, probably, but that's still ~160 algs for ZZLL and ~100 for algorithmic phasing.

#### Hazel

Phasing + ZZLL, probably, but that's still ~160 algs for ZZLL and ~100 for algorithmic phasing.
I thought you only really needed something like 3 different insertions for phasing during the last slot?

#### xyzzy

##### Member
I thought you only really needed something like 3 different insertions for phasing during the last slot?
That's if you form the pair first. Without forming the pair first, there are (roughly) however many last slot cases are possible, multiplied by three.

#### Hazel

That's if you form the pair first. Without forming the pair first, there are (roughly) however many last slot cases are possible, multiplied by three.
Interesting. Where could I find algs for this? And is it worth it to know all the phasing algs or is it generally better to just learn the 3 insertion cases?

#### xyzzy

##### Member
Interesting. Where could I find algs for this? And is it worth it to know all the phasing algs or is it generally better to just learn the 3 insertion cases?

I honestly have no clue if it's actually worth learning all of these versus just forming the pair, though. And in fact, a fair number of those cases are the same as intuitive phasing, and most of the remaining cases look like they're just forming the pair in different (but still intuitive) ways, so maybe learning all of them is less daunting than it seems.

#### PetrusQuber

##### Member
How to be Sub 20 (Petrus)
Ok so you know the original ‘How to be Sub 20’ thread, yes? It talks about Fridrich. Well, I thought-‘there are 3 other main methods here? Why not talk about them?’ So I decided to create a Petrus thread here. It would be great if ZZ and Roux users could create these as well. So here we go! Note:This is not for beginners. Go to lar5.com first for the basics.

1. Be colour neutral. Seriously, without it, you cannot be efficient with Petrus. Get working on it right now if you haven’t already, and aim for dual colour neutrality first.
2. Do not be stuck with one method of creating a block all the time. Adapt to your situation. If there is a partially formed cross, insert a corner to create a 2x2x1. If there’s a ‘roundabout’ situation which could create a 2x2x1 easily, use it.
3. Make sure your technique is correct before you practise it. Bad habits die hard.
4. Make sure you are looking ahead at the appropriate times (the end of a step) to maintain fluidity. The best way is to slow down until you can solve without stopping, then speed up
(Sub 5)
At this point, you should have learnt all the blockbuilding tricks from lar5.com already. If you haven’t, do so.
Your technique should be based on Erik Johnson’s (whose method of blockbuilding is a good example to all) or at least based on it. Find an edge already attached to one of its colours (or both) as you can create a line/inner 2x2x1 square easily. Then check out the two corners which could go with the square and choose the one which can be formed into a pair easily. Then attach the last edge to build another square and slide the two 2x2x1s together.Make sure the building of the outer square is not interfered with by the first edge. Of course, you should not be restricted to just this - implement any of the blockbuilding tricks from before and take advantage of already formed pairs.
Lastly, you should use your inspection time to decide which first edge and after that which corner to use, and find all the pieces you need. Try to be able to do your 2x2x2 blindfolded.
Plus, make sure you are looking for 2x2x3 pieces as soon as possible. Try not to end up with your 2x2x2 at FLD/FRD - go for BLD (no not blindfolded) but if you do end up like that, try tilting your cube using - half y/y', x'
(Sub 4)
The transition in between steps 1&2 should be smooth, with no pauses. As mentioned earlier, start looking for your 3 pieces as soon as possible, and also pick the easiest corner to start with. How to do this? Make sure you remember the 3 colours of your 2x2x2 block, and look for corners with two of those colours. Quickly see if there are any edge pieces that could form the first pair nearby, and if it's an easy case, go for it. Otherwise, move onto the next corner. The obvious ones to pick are the corners already in a 2x2x1, in a pair, or part of a simple join (one move pair).
Once you've found the easiest corner, execute the moves needed for pairing as fast as you can and look for the last edge. If the pairing process takes a long time, start looking while you are doing it. At this point, the edge or the pair will need to be on the top layer for connection, so if one is not already there, make sure it is. Then implement basic blockbuilding from step 1, and bring the 2x2x1 in to form the 2x2x3. If the pair is already in its position (where the 2x2x1 needs to be to count as a 2x2x3), break the first block you made and bring down the pair so it is not in the top layer anymore, then put the edge where it needs to be, and when you restore the block by bringing the pair up again, you will form a 2x2x1!
(sub 3)
Last thing to remember, as you finish off your last set of edges, start looking for your next corner and edge pieces, lr you'll hesitate again. You can start looking even before that.
(Sub 7)
Here is a quick note-Petrus F2L is NOT like Fridrich F2L. It is based on blockbuilding (except for the last bit, where it's two gen anyway) so unless you can benefit from already placed edges or pairs or whatever, do not go for it. Just use techniques from previous steps to build the 2x2x1. Petrus should be flexible, as I said earlier. Anyway, like all other steps, this step should have no pauses in it at all, and should flow smoothly from Edge Orientation, as you have already found some of the pieces.
Basic pairing and joining techniques is used here-there shouldn't be anything you haven't already done in steps 1&2. Of course, it is good to know some specific special cases like 'the broken corner' and 'the parallel roundabout' but you won't need much else here, except the ability to find things and see how they can be connected. If you don't have that skill, get onto it. Slow practise will help.But the main thing is-DO NOT do what I did when I started out, which was to place the corner, correctly oriented, where it should go, then used the separation points (FUR and BUR) to connect it with other pieces one by one. It may be faster sometimes, but that is only in the short term, as its very routine and easy to get used to. So practise being flexible, once again, if you are doing what I used to do. Another important thing to consider is that rotationg the cube while solving this step slows you down. So don't do rotations. This means that you will have to either build the 2x2x1 or slot in the F2L pair at the back. (I am assuming you have adopted the classic RU F2l.) I chose to build the block at the back, since you had more freedom to build it than when slotting the pair in, but it is up to you.
Moving onto the F2l pair, you should understand that all of your algorithms have to be 2 gen (or not affect EO). Or you have to go through two look OLL. So quickly check through to make sure they are. Finished? Great! Then you should be done with this step, actually. There really isn't much to it other than algs, algs, algs. But I suppose that's another point. Learn your algorithms from Lar's page, or you'll end up with non 2 gen algs, but also, make you know which ones are not worht copying. Take the two cases where the corner is wrongly oriented, but this step is otherwise done. Petrus' algs there are focusing on FMC there, and aren't good for speedsolving. Just break the pair out and simplify. Another one is the 3rd 'corner already placed' one. I think that the double moves are not worth it and ended up with R U R' U' R U R' (edge's side colour matching up with centre). It may have more moves, but is faster in terms of finger trickiness. Another one is the first 'edges already placed' one. Just do R U R' U' then return to the last case I gave you a new alg for. Last of all is the first 'corners already places' one. Don't bother with it. Just do a U2 and use the alg mentioned in the actual Step 4b intermediate section. There may be other cases I forgotten, but you'll have to find them yourself. NOTE:THOSE ALGS ARE DONE AS IF THE SLOT IS CLOSE TO YOU.
(sub 5)
Like most methods, Petrus doesn't really have a specified last layer. Petrus himself used CP CO EP, combining at least one step (like COLL) using combos. However, most Petrus users use OCLL/PLL, COLL/EPLL, so I will be talking about those. Since Petrus preorients last layer edges, you should, at the very least, be using a 3 look last layer system. Preferrably two look. I personally use OCLL and PLL, having learnt full PlL (14 more algs) but COLL and EPLL is another way of doing it. PLL cases are easier to recognise in my opinion, but if you use COLL, there is a greater chance of skipping PLL, and failing that, an easy U/H/Z perm. However, there is a great deal more algs to learn - 42 of them, but Sune and Anti Sune cases shouldn't be used, and you will know the odd case here and then, so the actual number comes down to around 20 something. Its up to you which one to use, but once you get faster, you'll probably need both for certain cases. Anyway, with the last layer, all you need is to learn a two look system, get those algs into your muscle memory, and be able to do them in around 3 seconds plus recognition time. Two sided PLL recognition will help too. Just do a bunch of two gen scrambles, solve F2L, and drill last layer. This will help speed up your recognition, execution, and other things. If you wish, you can use CLS/EJF2L in your solves, allowing for quicker F2L. (So you misorient the corner during F2L intentionally to speed up the slotting process, and correct it during OCLL.)
I will do 5 random solves and implement all the techniques shown before, and you can follow along. They are listed below...
R2 U B D2 L2 R' U' B2 R B' L2 U2 R2 B2 L' D'
z y'//inspection//nice pair, two of the edges already connected.
D' R B' R D'//2x2x2 block//made sure block will be on the right.
L U' L2 F' L' F'//2x2x3 extension//simple join, then setup for double join.
d L F L2 U2 L//EO//4 bad edges, easy case.
d U R2 U' R2 U2 R U R' U' R U R'//F2L//pair already formed, double join, then one of the replacement algs.
U L' U' L U' L' U2 L//OCLL//left hand Sune.
U R' x U R' D2 R U' R' D2 x' R2//PLL//EPLL skip, so simple A perm.
U2//AUF//all done!
49 moves, some nice pairs, and edge pll skip. Apologies, I just realised that there were no F moves in that scramble. Oh well.
R2 F2 L U B2 D' U2 R L' F2 R' U' F B2 D U2
y2//inspection//two pairs, but closest one is easier.
D' F2 L F2 B D2//2x2x2//Fairly smooth, first move aligns inner square edge.
U2 F2 L//2x2x3 extension//Unbelievably easy simple join, then double join.
L' U L R U' R'//EO//4 bad edges again, easy recognition. (Could skip a move at the start)
d R' U R U' R' U R U2 R U R' U' R U R'//F2L//One of the times where two F2L pairs is needed.
U L' U' L U' L' U2 L//OCLL//Another left hand Sune.
U2 R' x U R' D2 R U' R' D2 x' R2//PLL//ANOTHER EPLL skip, then A perm.
U'//AUF//All done!
50 moves. Easy 2x2x3, Fridrich F2L, and a Last Layer identical to Scramble 1!
Now, this thread is underway, but currently, I am busy with other things, so I will complete a step of Petrus at least once a week.
Plus, if you have no idea what I'm talking about with 'roundabouts and broken corners' and Step 4bs, visit lar5.com and click on his tutorial.

Last edited:

#### aerocube

##### Member
what do you average on petrus atm?

#### PetrusQuber

##### Member
Actually, I’m not sub 20. In fact, I’m around 30 secs. But nobody else has created a thread like this, so why not?
Please point out things you disagree with if you use Petrus and have lower times than me.

Have to run

#### Cubingcubecuber

##### Member
I average 16 with Petrus, although it is not my main method(I use CFOP) and I think it is pretty good. I recommend learning PLL and COLL, although it isn’t “true Petrus”

It do 2x2x2, 2x2x3, F2L-1, EO, COLL(unless I have a sune or antisune and do OCLL), EPLL(unless I did OCLL so I do PLL)

I might not be true Petrus, but it is pretty fast

Last edited:

#### PetrusQuber

##### Member
I average 16 with Petrus, although it is not my main method(I use CFOP) and I think it is pretty good. I recommend learning PLL and COLL, although it isn’t “true Petrus”

It do 2x2x2, 2x2x3, 2x2x3 with a 1x2x2, EO, COLL(unless I have a sune or antisune and do OCLL), EPLL(unless I did OCLL so I do PLL)

I might not be true Petrus, but it is pretty fast
I do 2x2x2. 2x2x3, EO, F2L, OCLL, PLL. I will consider learning COLL and EPLL at one point.

#### petrouxer

##### Member
This thread has been very helpful for me as a noob petrus user. I also highly recommend the following guide.
http://cube.crider.co.uk/zz.php?p=f2l#blockbuilding

Perhaps it can be added to the blockbuilding resources. It's for ZZ F2L but the block building techniques are very much applicable to petrus after EO stage. It certainly helps give some ideas on how to do step 4a/4b (plus some multi-slotting approaches too) if you do not already have a CFOP background.

#### Cubingcubecuber

##### Member
I do 2x2x2. 2x2x3, EO, F2L, OCLL, PLL. I will consider learning COLL and EPLL at one point.
EPLL is just u perms, h perm, and z perm
It is edge PLL, so you already know it

#### PetrusQuber

##### Member
EPLL is just u perms, h perm, and z perm
It is edge PLL, so you already know it
Yes, I know, Im just commenting on that last layer system as a whole. COLLs the hard bit.
This thread has been very helpful for me as a noob petrus user. I also highly recommend the following guide.
http://cube.crider.co.uk/zz.php?p=f2l#blockbuilding

Perhaps it can be added to the blockbuilding resources. It's for ZZ F2L but the block building techniques are very much applicable to petrus after EO stage. It certainly helps give some ideas on how to do step 4a/4b (plus some multi-slotting approaches too) if you do not already have a CFOP background.

#### LucJar56

##### Member
Has anyone explored the leor-b variant; which is similar to Petrus but deals with 2x2x3 and EO differently.
Do people like it?

#### PetrusQuber

##### Member
It seems like a good method, and people say it is the better alternative to Petrus, so it must have been explored in some depth. However, I’m pretty sure nobody fast uses LEOR, as it’s even more tucked away in the shadows than Petrus, while CFOP is in the lime light. I feel it has potential, the only bit I’m not sure about is the EOFDBD. I might switch if Petrus doesn’t work out.

#### petrouxer

##### Member
I have a Giiker (i3s) cube and wanted to time petrus splits but could not find any app or webapp that has Petrus (it's mostly CFOP or Roux). So I started looking to build one myself. If you are interested in such a thing, then read on...

I found a Giiker timer app here: https://github.com/rafalcieslak/bluetoothcube
It works on android or linux. Note that this person made most of the app and I just forked his code. I just tacked on the petrus stages but I thought I should post it here in case someone has some use for it.

As you can see, it will give you "conventional" Petrus splits, including the Edge-Orientation phase. It is fully color-neutral aware.
Check it out: https://github.com/paulourriza/bluetoothcube (there's a pre-built image for Android in the bin/ directory)

EDIT: The note below no longer applies. It's fixed. Just grant the app location access when it asks (this is required to scan bluetooth LE devices, like the Giiker)
NOTE: I'm not much of an android programmer, so when it scans for your cube it will not find it at first. Be sure to grant the app Location access (app settings in android). I'll try to fix that soon.

I know for a fact that @Tao Yu, has a Giiker cube (saw on his videos). Perhaps he can give us some world-class Petrus splits (the sub 30 above is around what I can personally do)

Anyway, if you find any bugs. You can send me a message and I'll try to fix it. If you know some Python, you can also help make the app better.

Last edited: