#### Christopher Mowla

I think he meant that if you scramble the cube with <R,U>, then you solve DFR and DBR, then all the corners on the up side is permutated well (with AUF), and they only need an orientation. Equivalently: there is no PLL where you swap corners using only <R,U>. Somehow the permutation of the corners is restricted in <R,U>. The question is: why?
Oh. The answer boils down to something quite simple: you cannot isolate a corner in either the U face or R face using <U,R> turns.

Or, more generally,
You cannot put the DBR corner in the UBR slot preserving the formation of the remaining 3 corners in the U layer D R D' R', for example. If we could do this, then we could do a 2-cycle of corners if we accompany it with the proper 4-cycle of corners.

In more detail,
Using coldsun0630's first corner 3-cycle commutator's X as an example, U' R' F R U, obviously you could create a 3-cycle of corners using only U and R turns if you could isolate a corner like this. Since a product of 3-cycles can create all even permutations, we can see why we can't create all even permutations of corners using only U and R slices.

So suppose we started with an algorithm which does a 2-cycle of edges: U R2 U' R2 U R2 U' R2 U2 R2 U2 R2 U. If you can do a 2-cycle, you can do a product of that 2-cycle to create all odd and even permutations. So that's why we can have any permutation of the edges in the U and R faces (but we of course can't change their orientation).

This algorithm also does a 4-cycle of corners. So we need to do the proper 2 2-cycle of corners in order to make it a 2-cycle. A 2 2-cycle of corners can easily be done doing simply U2 or R2 (U2 if all 4 corners in the U face need to be in a "X" 2 2-cycle or R2 if ""...).

Using the same example algorithm which does a 2-cycle of edges and a 4-cycle of corners, let's start off with a solved cube and "force" DBR in the UBR slot without changing the formation of the remaining 3 corners in the U layer, do U2 (a 2 2-cycle of all the corners in U), and undo those "forced" setup moves:
(D R D' R') U2 (R D R' D')

Now let's add this 2 2-cycle to our 4-cycle algorithm to get a 2-cycle of corners:
U R2 U' R2 U R2 U' R2 U2 R2 U2 R2 U
(D R D' R') U2 (R D R' D')

As you can see, lacking the ability to isolate a corner is both the reason we cannot create all even permutations AND why we can't create all odd permutations.

Note that I could have easily created a 2-cycle of corners in the U face, for example, if I was able to create a 3-cycle of corners in the U face + either the move U or U', but I thought that the example I gave would be more satisfying.

Last edited:

#### coldsun0630

##### Member
I have an explanation for all 10 of your remaining algorithms.
First of all, I haven't read cmowla's second and third writing. Because I didn't had much time to read that.
I was reading his first writing and analyzing his decomposition. I'm very sorry about that.

In the writing, some of the decomposition was impossible to understand to me, so I decided to try to decompose them in defference way, and I got some outputs.
R' U R U' R' F' U' F R U R' F R' F' R U' R (N Perm)
R' U R U' R' // setup move
F' U' F R U R' F' U F U' // 3 pair cycle
U F' U' F // 3 edge cycle, 2x2 corner cycle
F R' F' R // 3 edge cycle, 2x2 corner cycle
R U' R' U // 3 edge cycle, 2x2 corner cycle
U' // extra quarter turn
R U R' U' R // reverse setup move
View at alg.garron.us

Without the setup moves, it is ZBLL-T R Perm.
I couldn't understand this alg perfectly because I don't know how (U F' U' F2 R' F' R2 U' R' U) works.
F' U F' U' R' F' R2 U' R' U R' F R F (V Perm)
- Skeleton: F' U F' U' F' U F' U' F' // 2 edge, 4 corner cycle
F' U F' U' F' U F'
F' U' // setup move
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' // 2x2 corner cycle (E Perm)
U F // reverse setup move
U' F'
View at alg.garron.us

I don't know how (F' U F' U' F' U F' U' F') makes 2 edge, 4 corner cycle,
and I also don't know how (U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U') makes E Perm.

+
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' (E Perm)
U F2 U'
F R' F' R
R U' R' U
R' F R F'
F' U F' U'
View at alg.garron.us

There's no meant.

...and while the term of the days, I got some more questions.
1. How (U F' U' F2 R' F' R2 U' R' U) works?

2. How (F' U F' U' F' U F' U' F') makes 2 edge, 4 corner cycle? and how to write this alg in commutator?

3. How (U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U') makes E Perm?

4. How [R U R' U', R' U2 R] works?

5. What is 'extra quarter turn' actually means? What is 'do extra quarter turn'?

Last edited:

#### Lagom

##### Member
When you started doing OH, did you have to re-learn a lot of algs?

Since i pretty much know full OLL 2h, I would really like to be able to learn how to do all these algs 2h without having to re-learn them for OH muscle memory...
I just can´t do it tho, all algs are in my muscle memory and I can´t do them slowly.

Or is it just easier to learn all OH OLLS?

#### jayefbe

##### Member
When you started doing OH, did you have to re-learn a lot of algs?

Since i pretty much know full OLL 2h, I would really like to be able to learn how to do all these algs 2h without having to re-learn them for OH muscle memory...
I just can´t do it tho, all algs are in my muscle memory and I can´t do them slowly.

Or is it just easier to learn all OH OLLS?
If you want to be fast, you really have to learn OH algs at some point. I didn't for a long time, and am finding switching to better OH algs has a huge effect. I also find it hard to use 2H algs in OH, you still need to develop new OH muscle memory.

#### coldsun0630

##### Member
Hey coldsun0630, The 8 algorithms you asked about can be broken into 3 categories; and I will touch on them all. The first two categories are related, as you will soon see.
Oh. The answer boils down to something quite simple: you cannot isolate a corner in either the U face or R face using <U,R> turns.
Your explanation was enough to understand eventhough I was novice on that area...
Anyway, thank you very much!

Last edited:

#### ben1996123

##### Banned
HTM move optimal 2 edge flip: [F'EF',R2U2R2]

F'EF': flips UF
U2: switches UB and UF
R2s: stuff

#### antoineccantin

##### Member
HTM move optimal 2 edge flip: [F'EF',R2U2R2]

F'EF': flips UF
U2: switches UB and UF
R2s: stuff
This does a 3 edge cycle.

#### ben1996123

##### Banned
This does a 3 edge cycle.
it does if you dont know what E moves are

#### coldsun0630

##### Member
PLL Decomposition Set

Since one and half years ago, I saw some PLL algs were decomposed in this page, which were done by cmolwa. I tried to understand how does these PLL algs work with his table, some of them were successful, but some of them were failed. So, I tried to explain myself these PLL algs in my way, and the below is the result. Some of those algs were not finished decomposing yet (which you can see 'Temp'), but since I can't continue cubing for a long while for now, so I'm going to post my old result here now.
Some of those decomposition were done clearly by cmolwa, so I'd let you know which were done by him. I also thanks to cmolwa who answered my bunch of questions kindly before.

* '(Temp)' is a mark that decomposing the alg were not finished yet, or I haven't understand how the alg works intuitively yet.

/

Edit: All decompositions were moved. Please check this post.

Last edited:

#### coldsun0630

##### Member
+ some other things

I tried to decompose the V Perm alg before, but I couldn't find any worth things. This is the result. (I saw that I've posted here before, so I'm just copying it.)
F' U F' U' R' F' R2 U' R' U R' F R F (V Perm)
- Skeleton: F' U F' U' F' U F' U' F' // 2 edge, 4 corner cycle

F' U F' U' F' U F'
F' U' // setup move
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' // 2x2 corner cycle (E Perm)
U F // reverse setup move
U' F'
View at alg.garron.us

I don't know how (F' U F' U' F' U F' U' F') makes 2 edge, 4 corner cycle,
and I also don't know how (U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U') makes E Perm.

+
U F2 U' F R' F' R2 U' R' U R' F R F2 U F' U' (E Perm)
U F2 U'
F R' F' R
R U' R' U
R' F R F'
F' U F' U'
View at alg.garron.us

There's no meant.
R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm)
(R' U' R U' R U) R2 (U R U' R U' R') U2 // 3 edge cycle
U2 R U R' U // setup move
(R' U' R' U') R' (U R U R) U // 3 edge cycle
U' R U' R' U2 // reverse setup move

/

Also, I have some question that I've curioused for a long time. The questions are below:
1. At BH Corners, What makes 8 turns 3-cycle of corner algs devide into 3 different cases, Direct Insert, Drop and Catch and Toss Up?
2. How the 3-cycle of edges algorithm(R2 B2 L2 U L2 B2 R2 D) does work?
3. What does the 10-turns case mean, 'Orthogonals'?

That's all for now. Thank you.

/

Edit: All problems were solved.

Last edited:

#### coldsun0630

##### Member
Yet Another PLL Decomposition Set

After two and half years from my first attempt, finally I finished to decompose the whole PLL sets(I have) in my way. I did this because some algs were remained 'not understood' for me.

I tried to decompose them as possible as I can, not only to explain with commutators/conjugates, but also to find what we understood already. It means(for instance), I tried to explain the algs with pure-3 cycles or sexy moves, not using some uncommon commutators, such as [F' R U2, R']. So, I believe this is more easy-to-understand than the current Christopher Mowla's decomposition.(on this thread, SS Wiki, or elsewhere.)

Some comparisons are at below.(I edited his decomposition to make similar with my explanation form.)

R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm)
[U R: [(R' U')2: R'] U [U' R' U' R' U': R2] U2 [U2: [(U' R')2: U2] R2][U2 R2: U2] R2][U R': U2 [(R U)2: R2]]

U R // setup move 1 (cyclic shift)
(R' U' R' U') R' (U R U R) U // edge 3-cycle
(U' R' U' R' U') R2 (U R U R U) U2 // edge 3-cycle
U2 // setup move 2
(U' R' U' R') U2 (R U R U) R2 // edge 3-cycle
U2 // reverse setup move 2
(U2 R2) U2 (R2 U2) R2 // edge 2x2-cycle
R' U' // reverse setup move 1
U R' // setup move 3
U2 (R U R U) R2 (U' R' U' R') // edge 3-cycle
R U' // reverse setup move 3

View at alg.cubing.net
[U': [[U, R'], [U', R]][U' R U R' U: [(R' U')2: R'] U]]

U' // setup move 1 (cyclic shift)
(U R' U' R) (U' R U R') (R' U R U') (R U' R' U) // edge 3-cycle
U' R U R' U // setup move 2 (insertion)
(R' U' R' U') R' (U R U R) U // edge 3-cycle
U' R U' R' U // reverse setup move 2
U // reverse setup move 1

View at alg.cubing.net

R U R' U' R' U R U2 R' L' U R U' L U' R U' R' (F Perm)
[R U R' U': [R' U: [R, U2]][R', [U': L']] U]

R U R' U' // setup move 1
R' U // setup move 2
R U2 R' U2 // commutator - [R, U2]
U' R // reverse setup move 2
R' (U' L' U) R (U' L U) // corner 3-cycle
U // extra quarter turn
U R U' R' // reverse setup move 1

View at alg.cubing.net
[R U R' U': [U' R': [R U : [R', U]][L', [U: R]] U]]

R U R' U' // setup move 1
U' R' // setup move 2 (cyclic shift)
R U // setup move 3
R' U R U' // edge 3-cycle, corner 2x2-cycle
U' R' // reverse setup move 3
L' (U R U') L (U R' U') // corner 3-cycle
U // extra quarter turn
R U // reverse setup move 2
U R U' R' // reverse setup move 1

View at alg.cubing.net

R U R' F' R U2 R' U2 R' F R U R U2 R' U' (R Perm)
[R U: [R': [F' R U2, R']][R', U] U' [R', U']]

R U // setup move 1
R' // setup move 2
(F' R U2) R' (U2 R' F) R // commutator - [F' R U2, R']
R // reverse setup move 2
R' U R U' // edge 3-cycle, corner 2x2-cycle
U' // extra quarter turn
R' U' R U // edge 3-cycle, corner 2x2-cycle
U' R' // reverse setup move 1

View at alg.cubing.net
[R U R' F': [R U: [U, R']][R U R' U' R', F]] U'

R U R' F' // setup move 1
R U // setup move 2
U R' U' R // edge 3-cycle, corner 2x2-cycle
U' R' // reverse setup move 2
(R U R' U' R') F (R U R U' R') F' // corner 3-cycle
F R U' R' // reverse setup move 1
U' // extra quarter turn

View at alg.cubing.net

F' U F' U' R' F' R2 U' R' U R' F R F (V Perm)
[F' R' F' R: [R' F R U: F'][R, U']]

F' R' F' R // setup move 1
R' F R U // setup move 2
F' // transposition
U' R' F' R // reverse setup move 2
R U' R' U // edge 3-cycle, corner 2x2-cycle
R' F R F // reverse setup move 1

View at alg.cubing.net
[F' U F' U' F': [F, R'][R, U'][U, F'][F', U F U' R'] F']

F' U F' U' F'// setup move
(F R' F' R) (R U' R' U) (U F' U' F) // orient 5 pieces
F' (U F U' R') F (R U F' U') // pair 3-cycle
F' // extra quarter turn
F U F U' F // reverse setup move

View at alg.cubing.net

Actually, my PLL set doesn't contains the whole algs on SS Wiki. There are a lot of same algs(rotation, mirror, inverse, etc.), and that's why I didn't check there. If I have more time later, I will do the decomposition of them, too. But, it still contains a bunch of algs!

I merged my whole decomposition set in a single post on my blog, so you can see it at here. Well, the post contains some Korean texts, but they are not really important. All of the explanation were written in English.

Last edited:

#### Christopher Mowla

And also, any feedback is welcomed!
I first note that the inverse of my decomposition for the v perm is much easier to understand than how it's currently written in your post (at least to me). (I think this modification makes it easier-to-understand than yours, as it follows the "classic" parity algorithm setup.) But your representation is creative. That must have taken a while to make.

As far as the rest of yours, they are too similar to mine for the most part for me to think that they are that much better than the ones I presented, but I agree you did improve on them. I taught you well!

Now, I have come up with a new presentation for the first three cases you listed, as to give us all another perspective on the matter.

They all have sune-type algorithms in them, which I think many on here will like.

I can't say that this is the best possible way to make this alg more understandable, because the second algorithm piece is quite long, but it is certainly better than the other ones, IMO.

R' U' R U' R' U2 R U2 // (sune with all moves inverted/sune rotated about y2 and mirrored about M) + U2
U2 R' U2 R2 U R U' R' U R U R2 U' R' U2 //a long sune alg.

Combine and cancel moves, we get the alg.

R U R' U R U2 R'

[2] Add 3 corner cycle, L' U R U' L U R' U'

R U R' U R U2 R'
L' U R U' L U R' U'

R U R' U R U2 R'
L' U R U' L U R' U'
(U)

[4] Shift
R' U R U2 R'
L' U R U' L U R' U'
(U) R U

[5] Conjugate
R U R' U'
R' U R U2 R'
L' U R U' L U R' U'
(U) R U
U R U' R'

[6] Cancel moves
= R U R' U' R' U R U2 R' L' U R U' L U' R U' R'

#### coldsun0630

##### Member
Re: Feedback

I agree you did improve on them. I taught you well!
Hello again, it's nice to see you! It has been for a while since I learned from you how algs does works on the cube. At that time, actually I wasn't experienced enough at cubing. So I could figure out some easy algs like some U Perms or J Perms, but I failed to decompose other computer-generated algs, so I asked here about them before. Most of them were answered on your old post, and it was very, very helpful to understand the cube itself. I still appreciate you for this. But some of your description were not enough to accept, and that's why I tried to re-decompose the algs.

As far as the rest of yours, they are too similar to mine.
The decomposition set presents you "how I understood the algorithms", so it means they are just my collection, but not the "correct answer". Of coursely, the way to decompose could be same with yours. Some algs are so obvious that is hard to find other ways to decompose. But some algs are not: the decomposition may be varied by the difference of one's perspective. Oh, please be sure that the comparison is not to show that my explanation is better than yours, but to show that how the interpretation of each algs could be different.

Of course you may find some of them are too similar to yours, bacause some of them are actually "the same" to yours. As I said above, this is the way to understand how the algs work, but which I prefer. Some of your decomposition (from the old post) didn't worked for me, but the rest were very enough to explain. And this is why your explanation are included in my decomposition set. But I only brought them from the old post, so If mine and the SS Wiki one are same? Then I don't know, it's just an accident. Maybe they're in the first case, which the algs looks so obvious. Actually, most of the PLL algs are in this case.

I first note that the inverse of my decomposition for the V Perm is much easier to understand than how it's currently written in your post (at least to me).
I have two rules on my decomposition:
#1. Every moves should be reasonable.
#2. Each decomposition may compatible with its derivated algs.

For the rule #1, it means that an alg should be explained with series of elements, like commutators, setup moves, extra moves, etc.) And that's what decomposition is for. In this case, for me, a 'pure cycle' is more prefered than a sexy move, because a pure cycle looks more clear than [R, U], which swaps 7 pieces. So when I decomposing an alg, I usually try to avoid extra moves. And, this is why I decomposed the V Perm in another way. Of course your decomposition is still valid, and now I prefer your decomposition. Oh, I didn't added this on my decomposition set yet. I'm gonna edit the post soon.

For the rule #2, it means that if the basic structure/execution of two algs is same, it may decomposed in same way. If not, I would prefer a decomposition which can explain the both algs. Here's an example.
L F2 R2 D R D' R F2 L' U
The alg could be decomposed like this:
L F2 R2 D R D' R F2 L' U

L F2 R' // setup move
R' D R D' // sexy move (edge 3-cycle, corner 2x2-cycle)
R F2 L' // reverse setup move
U // extra quarter turn
I know another alg which solves same case.
R U2 R' L' U R U' L U2 R' U

R U' // setup move
U' R' [1] U R // sexy move
U R' // reverse setup move

Insert at [1]: L' U R U' L U R' U' // corner 3-cycle
...and you may see that it has the same structure with the shifted one.
R U2 R' L' U R U' L U2 R' U
= r U2 R' l' U R U' l U2 r' U
Then it may be decomposed in same way. The alternative decomposition is following:
R U2 R' L' U R U' L U2 R' U

l F2 r' // setup move
R' D R D' // sexy move (edge 3-cycle, corner 2x2-cycle)
r F2 l' // reverse setup move
U // extra quarter turn
r U2 R' l' U R U' l U2 r' U

r U' // setup move
U' R' [1] U R // sexy move
U r' // reverse setup move

Insert at [1]: l' U R U' l U R' U' // pair 3-cycle

They all have sune-type algorithms in them, which I think many on here will like.
Okay. Let's take a look one by one.

R' U' R U' R U R U' R' U R U R2 U' R' U2 (Z Perm): Two Algorithm Combination

R' U' R U' R' U2 R U2 // sune alg + U2
U2 R' U2 R2 U R U' R' U R U R2 U' R' U2 // a long sune alg
Well, I edited the post once because I copied wrong decomposition of the Z Perm. So, I wonder if you saw this new one:
U' // setup move 1 (cyclic shift)
(U R' U' R) (U' R U R') (R' U R [1] U') (R U' R' U) // edge 3-cycle
U // reverse setup move 1

Insert at [1]: (R' U' R' U') R' (U R U R) U // edge 3-cycle
(The key algorithm is [U R' U' R, U' R U R'], and I think it's not really hard to understand.)

Your decomposition doesn't satisfy my rule #1, at least for me, because it actually seems just a coincidence. the short sune alg can be explained as [R' U': [R, U']]. The [R, U'] explains everything about the 3-cycle of edges and the orientation state of corners. But I don't think that 'a long sune alg' could be explained as simple as the first one. I love simple and precise one so I don't like this explanation. I'd rather prefer your previous decomposition which explains with five 'pure' cycles.

R U R' U' R' U R U2 R' L' U R U' L U' R U' R' (F Perm): Derivation:

R U R' U' // setup move 1
R' U R U2 R' [1] U R U // shifted sune alg + extra quarter turn
U R U' R' // reverse setup move

Insert at [1]: L' U R U' L U R' U' // corner 3-cycle
Well, this is basically same as my explanation. I always decompose sune algs using 2-moves-conjugation and sexy move. And for the shift, I was used to explain it with setup moves, which called "cyclic shift". (I brought the term from BH Method.) In this case, I explain the shift like this:
R' U R U2 R' U R U
U' R' // setup move (cyclic shift)
R' U R U2 R' U R U // sune alg + extra quarter turn
R U // reverse setup move

Oh, I actually was able to reduce the number of setup moves! Here's my updated one.
R U R' U' R' U R U2 R' L' U R U' L U' R U' R'
[R U R' U': [R', U][U' R': [L', [U: R]] U]]

R U R' U' // setup move 1
R' U R U' // edge 3-cycle, corner 2x2-cycle
U' R' // setup move 2
L' (U R U') L (U R' U') // corner 3-cycle
U // extra quarter turn
R U // reverse setup move 2
U R U' R' // reverse setup move 1

View at alg.cubing.net

R U R' F' R U2 R' U2 R' F R U R U2 R' U' (R Perm): Derivation:

R U' R' U2 // setup move 1
R' // setup move 2
(R U2 R U2 R') F' (R U2 R' U2 R') F // corner 3-cycle
R // reverse setup move 2
U' // extra quarter turn
U2 // setup move 3
R U2 R' U' R U' R' // sune alg
U2 // reverse setup move 2
U2 R U R' // reverse setup move 1
Firstly, my decomposition is sune type alg, too!
R U R' F' // setup move
R U2 R' U' R U' R' // a sune alg
(R U R' U' R') F (R U R U' R') F' // corner 3-cycle
F R U' R' // reverse setup move
U' // extra quarter turn

Well, I arranged your decomposition a bit.
R U' // setup move
(U2 R' F' R U2) R' (U2 R' F R U2) R // corner 3-cycle
R' U' R U2 R' U' R U' // shifted sune alg + extra quarter turn
U R' // reverse setup move
[R U': [U2 R' F' R U2, R'][R', U']] U'

R U' // setup move
(U2 R' F' R U2) R' (U2 R' F R U2) R // corner 3-cycle
R' U' R U // edge 3-cycle, corner 2x2-cycle
U R' // reverse setup move
U' // extra quarter turn

View at alg.cubing.net
Wow, this version of decomposition is much better! I will add it on my list. Thank you for giving me another look!

Well actually, I have a problem with the R Perm decomposition. In my old decomposition, I took setup move [R U R' F'], because of my rule #2. But I failed to decompose which compatible with these alg. Would you please decompose them with a same explanation?
R U R' F' R U (　　　　 )　R' U' R' F R (　　　　 )　R U' R' // [J Perm]
R U R' F' R U (U R' U' R)　R' U' R' F R (U R U' R')　R U' R' // [R Perm]
R U R' F' R U (U R' U' R)2 R' U' R' F R (U R U' R')2 R U' R' // [G Perm]
R U R' F' R U (U R' U' R)3 R' U' R' F R (U R U' R')3 R U' R' // [J Perm]
R U R' F' R U (R' U R U')2 R' U' R' F R (R U R' U')2 R U' R' // [R Perm]
R U R' F' R U (R' U R U')　R' U' R' F R (R U R' U')　R U' R' // [G Perm]

It's all for now. Thank you for your response!

Last edited:

#### coldsun0630

##### Member
An answer for my old question:
Re: Feedback

Well actually, I have a problem with the R Perm decomposition. In my old decomposition, I took setup move [R U R' F'], because of my rule #2. But I failed to decompose which compatible with these alg. Would you please decompose them with a same explanation?
R U R' F' R U (　　　　 )　R' U' R' F R (　　　　 )　R U' R' // [J Perm]
R U R' F' R U (U R' U' R)　R' U' R' F R (U R U' R')　R U' R' // [R Perm]
R U R' F' R U (U R' U' R)2 R' U' R' F R (U R U' R')2 R U' R' // [G Perm]
R U R' F' R U (U R' U' R)3 R' U' R' F R (U R U' R')3 R U' R' // [J Perm]
R U R' F' R U (R' U R U')2 R' U' R' F R (R U R' U')2 R U' R' // [R Perm]
R U R' F' R U (R' U R U')　R' U' R' F R (R U R' U')　R U' R' // [G Perm]
R U R' F' R U R' [1] U' R' F R2 U' R' (U')
[1]: [[R, U]*n, [U', l']]

i) n=3k+1: PLL R-Perm
ii) n=3k+2: PLL G-Perm
iii) n=3k: PLL J-Perm (the insertion does nothing.)