While we are on small flips. Here is another one for odd sized cubes:

U 4 small flips.

The 3x3x3 cube has a shorter version sequence that does not generalize to higher order:

U 4-flip.

Per

V7 super small flips.

Profesor super small flips.

Glazik's approach won't work on odd sized cubes (not for the middlemost edges).

Per

8 small middle flips.

Pursueing the small flips is interesting

Per

Now flipping the 4 small edges on the middlemost layer:

Middlemost layer 4 flip.

Simply commute B R- F D- SR U F- L with MU2

Per

More fun with rings. Based on the "well known" M2 F2 U' S2 E2 M2 D' B2 L' S2 E2 R'

Apply this first and then the reverse of double layer version.

8 small alternating rings.

Per

Didn't I mention my algorithms were unoptimized versions?
Anyway, thanks for sharing!

Here is an optimized version of the 4 Deep Flips pattern (14 moves):
(NF TU2 NB') (NF' TU2 NF TU2) (NF' TU2 NB) (NF TU2 NF' TU2)
4 Deep Flips

Disgression on semi-commutators
You may have noticed that this alg looks like a commutator [A,B], but here the directions of A' and B' have not been reversed. So it's not really a commutator, but a product of commutators. In my personal notation, I called that a 'semi-commutator', where the direction of the reversal is given by that of the enclosing brackets:

]NF TU2 NB', NF' TU2 NF TU2[ = (NF TU2 NB') (NF' TU2 NF TU2) (NF' TU2 NB) (NF TU2 NF' TU2)

It can be shown that products of commutators resulting in semi-commutators can give a (nearly) maximum number of move cancellations as shown below for a product of 3 commutators:
]XY, ZP[ = [X, Y] [YX, ZP] [Z, P] = X Y X' Y' YX ZP X'Y' P'Z' Z P Z' P' = XY ZP X'Y' Z'P'

What I mean is that semi-commutators may sometimes give shorter algorithms than commutators.

And yet one more:

8 small triple cubes.

Per

Edit:
Some turns can be saved on the V6 version of this pattern:
8 small triple cubes (V6).

Per

Bouncing on Per's idea about the 8 small corner rings pattern, I applied it to 8 tetrad rings (see tetrad on Jaap Puzzle Page on symmetry):

Part 1:
- written as (Alg 1) (Alg 2), where Alg 1 transforms to Alg 2 by 180° symmetry about the FD – UB axis
- two tetrads: one is twisted clockwise and the other counterclockwise
(B2 D2 B' R2 U D L2 B') (U2 F2 U' L2 B F R2 U') (16f*)

Part 2:
(TU TR2 TF' TB' TL2 TU TF2 TU2) (TB TL2 TD' TU' TR2 TB TD2 TB2)

8 Tetrad Rings 4x (31 moves)

8 Tetrad Rings 5x (31 moves)

Notice that there could be other ways of designing these algorithms, but I found this idea quite interesting

@ Glazik:

Why don't you write explicitly that ]X,Y[ = X Y X' Y ??
And one more kind of semicommutator would be like
semicommutator2(,X,Y)=X Y X Y'

I don't know what a good notation might be

Per

I found another way to do 4 small flips.

It is a simple commutator and only takes 16 turns:

[N2R- D2 N2L2 D2 N2R,F R- F-]

And a Slice 8 small flips.

Per

If X and Y are individual moves, then ]X, Y], [X, Y[ and ]X, Y[ are exactly the same as [X, Y],
but ]X Y Z, P Q[ = X Y Z P Q X' Y' Z' P' Q' is not the same as [X Y Z, P Q].

This is to give more insight into the semi notation:
If A and B are blocks of moves, commutators and conjugators are generally defined as:
[A, B] = A B A' B'
[A: B] = A B A'

A and B can be composed of individual moves like X, Y, Z, P, Q, A, etc..., so that we can get, for example:
Case 1:
[X Y Z, P Q] = X Y Z P Q Z' Y' X' Q' P'
[X Y Z: P Q] = X Y Z P Q Z' Y' X'

Now, considering semi-commutators and semi-conjugators, we have 3 additional cases, depending on the orientation of closing brackets:
Case 2:
]X Y Z, P Q] = X Y Z P Q X' Y' Z' Q' P'
]X Y Z: P Q] = X Y Z P Q X' Y' Z'

Case 3:
[X Y Z, P Q[ = X Y Z P Q Z' Y' X' P' Q'
[X Y Z: P Q[ = X Y Z P Q Z' Y' X' (same as [X Y Z: P Q])

Case 4:
]X Y Z, P Q[ = X Y Z P Q X' Y' Z' P' Q'
]X Y Z: P Q[ = X Y Z P Q X' Y' Z'

I note that commutators are much easier to use than their semi versions, when trying to solve a pattern by hand or paper and pencil, but they may be useful for building databases of short algorithms by computer. Semi-commutators may account for a not-so-tiny part of an algorithm database, especially for databases of more than 3 permuted pieces.

I have been using this notation for quite a long time when searching for short algs by computer and seen no particular problem with it.

In a way similar to the corner-ring twists patterns, substractive patterning can also be applied to edges to give edge-ring patterns - very straightforward, actually

Narrow midge flips are first patterned followed by wide-edge flips that will cancel the first flips. The net result is a series of rings around midges.

A few Edge-Ring Flips have already been published (see 2 Edge-Ring Flips (4x3)), so this will just add some more patterns.

Per's algorithms have been transformed and applied to wide-edge flips

Notice that the following algorithms have not been optimized yet.

2 Edge-Ring Flips – Opposed – Same Face
R U' MF U R' F U' R MF' R' U F'
TF TU' TR M3F TR' TU TF' TR TU' M3F' TU TR'
Algorithm (23 moves):
R U' MF U R' F U' R MF' R' U NF TU' TR M3F TR' TU TF' TR TU' M3F' TU TR'
2 Edge-Ring Flips – Opposed – Same Face


2 Edge-Ring Flips – Opposed – Same Slice
[MR2, F D' L F' D]
[TF TD' TL TF' TD, M3R2]
Algorithm (23 moves):
MR2 F D' L F' D MR2 D' F L' D NF TD' TL TF' TD M3R2 TD' TF TL' TD TF' M3R2
2 Edge-Ring Flips – Opposed – Same Slice


4 Edge-Ring Flips - Same Face
[U D MF2 MR' U' D' MF2, R]
[TR, TU TD M3F2 M3R' TU' TD' M3F2]
Algorithm (31 moves):
U D MF2 MR' U' D' MF2 R MF2 D U MR MF2 D' U' NR TU TD M3F2 M3R' TU' TD' M3F2 TR' M3F2 TD TU M3R M3F2 TD' TU'
4 Edge-Ring Flips - Same Face


4 Edge-Ring Flips – Same Slice
[MU2, R' F D' SR U F' L]
[TR' TF TD' TR TL' TU TF' TL, M3U2]
Algorithm (33 moves):
MU2 R' F D' SR U F' L MU2 L' F U' SR' D F' NR' TF TD' TR TL' TU TF' TL M3U2 TL' TF TU' TL TR' TD TF' TR M3U2
4 Edge-Ring Flips – Same Slice


8 Edge-Ring Flips – 2 Opposed Faces
[SR' SF SR, R2 MF R2 MF2]
[TR2 M3F TR2 M3F2, TL TR' TL TF TB' TR TL']
Algorithm (32 moves):
SR' SF SR R2 MF R2 MF2 SR' SF' SR MF2 R2 MF' NR2 M3F TR2 M3F2 TL2 TR' TF TB' TR TL' M3F2 TR2 M3F' TR TL TB TF' TL2 TR
8 Edge-Ring Flips – 2 Opposed Faces


12 Edge-Ring Flips
[MU2 MR2 MF2, B L B2 D F D R D2 B U]
[TB TL TB2 TD TF TD TR TD2 TB TU, M3U2 M3R2 M3F2]
Algorithm (51 moves):
MU2 MR2 MF2 B L B2 D F D R D2 B U MF2 MR2 MU2 U' B' D2 R' D' F' D' B2 L' NB TL TB2 TD TF TD TR TD2 TB TU M3U2 M3R2 M3F2 TU' TB' TD2 TR' TD' TF' TD' TB2 TL' TB' M3F2 M3R2 M3U2
12 Edge-Ring Flips

Stunning stack of patterns Glazik

I thought i would contribute an idea that suddenly came to me.

To understand i will start with easy example:

R U F- N2U2 F U- F- N2U2 F R- (edge 3-cycle) on 5x5x5 one could extend like so

R U F- N2U2 N2D2 F U- F- N2U2 N2D2 F R- (2 parallell 3-cycles)

With co-transportation one could do an easy conjugate to this second version.

N2R2 N2 F2 N2U2 R U F- N2U2 N2D2 F U- F- N2U2 N2D2 F R- N2U2 N2F2 N2R2

2 opposite edge 3-cycles.

Only 2 turns saved from the obvious way of doing it (repetition).

One more example:

Edge belt (halfway).

Again only 2 turns saved ...

There must be ways to exploit this technique for much greater saving on number of turns

Per

Edit:

Found a better example:

2 Alternating edge belts.

Here is a shorter version of

4 Edge-Ring Flips Same Face.

It is simply 2 consecutive comms:

[T2R2 M3F T2R2 M3F2, T2U]
and
[R- B MU- B2 MU2 B R,U2]

Per

Edit:
For the same slice version just add 2 setup turns first - gives 30 turns unoptimised.

4 Edge-Ring Flips (Same Slice).
Improved version. simply 2 parts:

T2R T2D2 M3F T2D2 T2L T2D2 M3F- T2D2 M3F2 T2L- M3F2 T2R- and
[R F- U SL D- F L-,MU2] cancelling 1 turn.

Per

Hmm Glazik !!
Your 8 Edge-Ring Flips Oppoced Faces pattern is NOT correct. Maybe you have a correct one and posted the wrong one instead

However i have a 33 turn correct version.

1. [R2 MF R2 MF2,SR- SF SR] ML U MF2 U2 MF2 U MR (8 small flips)
2. T2R T2L T2U- T2D- T2F T2B T2R- T2L- T2U T2D T2F- T2B-

8 Edge-Ring Flips Oppoced Faces.

Per

& Glazik: I replaced the 2nd part with

M3R- T2D T2R2 T2U2 M3F T2U- M3F2 M3R- T2D T2B2 T2U M3F2 T2D T2R2 T2D M3R2

and got the following for

12 Edge-Ring Flips. (Super Edge-Ring Flips)

Per

@ Per
Thanks for correcting and optimizing the algs!

Some algorithms have been improved, as shown below:

Opposed Edges 2(3c)
Previous algorithm (18 m)
(NR2 NF2 NU2 R) [U, F' NU2 ND2 F] (R' NU2 NF2 NR2)

Basic 3-cycle: Niklas commutator
[U, F' ND2 F]

Add slice move NU2
[U, F' ND2 NU2 F]

Use S moves instead of N moves, to lower move count
[SD', F' ND2 F]

Add 3 setup moves to get a 14-mover
(SR D2 L2) [SD', F' ND2 F] (L2 D2 SR')

Algorithm (14 moves)
SR D2 L2 SD' F' ND2 F SD F' ND2 F L2 D2 SR'
Opposed Edges 2(3c)

Edge Belt (Halfway)
Previous algorithm (18 m)
(NR2 NF2 NU2 F') [R U2 R', NU ND'] (F NU2 NF2 NR2)

Same process as above
(SL U2 L2) [F' ND2 F, SD] (L2 U2 SL')

Algorithm (14 moves)
SL U2 L2 F' ND2 F SD F' ND2 F SD' L2 U2 SL'
Edge Belt (Halfway)


2 Alternating Edge Belts
Previous algorithm (30 m)
(NR2 NF2 NU2) (F' R U2 R' NU ND' R U2 R' NU' ND F R F' U2 F NU' ND F' U2 F NU ND' R') (NU2 NF2 NR2)

First half
(R NU) [NU' ND', L' U' L] (NU' R')

Second half
(R' NF') [NB, L F L'] (NF R)

Algorithm (23 moves)
R ND' L' U' L ND NU L' U L NU' R2 NB L F L' NB' NF' L F' L' NF R
2 Alternating Edge Belts

I guess the following unoptimized algs might well be new

8 Opposed Rings (Faces R + L)
4 Midge Flips (Face R)
[U D MF2 MR' U' D' MF2, R] (16 m)

4 Midge Flips (Face L)
[U D MF2 MR U' D' MF2, L'] (16 m)

Insert + Cancel + Combine
[U D MF2 U' D' MF2, SR]

8 Opposed Rings (Faces R + L)
[U D MF2 D' U' MF2, SR]
[TR TL', TU TD M3F2 TD' TU' M3F2]

Algorithm (30 moves)
U D MF2 D' U' MF2 SR MF2 U D MF2 D' U' SR' TR TL' TU TD M3F2 TD' TU' M3F2 TL TR' M3F2 TU TD M3F2 TD' TU'
8 Opposed Rings (Faces R + L)

Super Deep Midge Flips
Super Midge Flips (16 s*) – 3x3x3 Cube
MR2 U' R2 D' MF MR2 U MR U2 F2 D' MF MR2 U' R2 U'

Super Deep Midge Flips (16 btm) – 7x7x7 Cube
MR2 T3U' T3R2 T3D' MF MR2 T3U MR T3U2 T3F2 T3D' MF MR2 T3U' T3R2 T3U'
Super Deep Midge Flips


12 Flipped Vees
A 12 Flipped Rings pattern variation.
Hint: 12 Block Flips first, Super Deep Midge Flips last

12 Block Flips
M3R2 TU' TR2 TD' M3F M3R2 TU M3R TU2 TF2 TD' M3F M3R2 TU' TR2 TU'

12 Flipped Vees
M3R2 TU' TR2 TD' M3F M3R2 TU M3R TU2 TF2 TD' M3F M3R2 TU' TR2 TU'
T3U T3R2 T3U MR2 MF' T3D T3F2 T3U2 MR' T3U' MR2 MF' T3D T3R2 T3U MR2

Algorithm (31 moves)
M3R2 TU' TR2 TD' M3F M3R2 TU M3R TU2 TF2 TD' M3F M3R2 TU' TR2 N3U T3R2 T3U MR2 MF' T3D T3F2 T3U2 MR' T3U' MR2 MF' T3D T3R2 T3U MR2
12 Flipped Vees

A huge improvement was found to the 8 opposed Rings (R+L).

Per

Oh, I completely missed that short 8-mover: [MU2, SF SU SF']!

The 8 Opposed Rings pattern can be extended to 12:
Pons Asinorum
M3F2 M3R2 M3U2

12 Opposed Midges
[MU2, SF SU SF']
[SF MU SF', SU2]
MU2 SF SU SF' MU2 SF SU' MU SF' SU2 SF MU' SF' SU2

Algorithm (17 moves)
M3F2 M3R2 M3U2 MU2 SF SU SF' MU2 SF SU' MU SF' SU2 SF MU' SF' SU2
12 Opposed Rings

A fairly straightforward pattern:
Algorithm (6 moves)
M3F2 M3R2 M3U2 MF2 MR2 MU2
12 Opposed Vees

Super opposed edge rings is also possible.

Small edges are permuted: U2 MR2 F2 MR2 F2 MF2 R2 MF2 MU2 F2 MU2 F2 R2 U2
Big edge blocks permuted: M3U2 M3R2 M3F2

A modest 17 turns. I cannot see any obvious ways it can be optimised

Per

6 opposite eyes.
After corner rings and edge rings i wanted to make center rings. This was a trivial start. Not highly optimised.

Per

6 opposite center rings. (larger eyes)

Done similarly to 6 opposite eyes pattern, but reversing 2nd part to achieve partial cancellation ...

Per

2 more easy patterns. They can be extended to 6 side versions resulting in shorter setups. However i found it more interesting to do them only on 3 adjacent sides (F,R and U)

The first one consists of 3 big rings.

Constructed from 2 parts:
[N2B- R2 N2B N2F R2 N2F-, WR] and
R [M3U-, N2B N2F- U N2B- N2F] R-

The second one is 3 big linked rings.

I simply extended the first pattern with
R [F- MU2 F, U] R-

I can make thicker rings, wider links etc etc ...

Per

4 Linked Big Rings (order 2).

Built from obvious 3 parts. Not optimised

Per

4 Linked Big Rings (order 2, version2).

Again : trivial parts and non-optimised

Per

@ Per
These are nice patterns indeed!

Continuing with centers, I tried to find a solution to centers of the Double Python pattern.
The solution is not optimized yet and a shorter one could certainly be found.
Combined with edges, the algorithm is 74 moves long, not a great move reduction...but maybe you could find a way to further improve the solution.

Centers 1
U MB MR' MU MR2 MU' MR MB' MR2 U'

Centers 2
R2 MU' TR2 MU' TR2 MB2 TR2 MU TR2 MB2 MU R2

Centers 3
WR2 WU' WR2 WU

Bloc (u, f)
MR' WD R2 WU MR ML WU' R2 WD' ML'

Bloc (u, d, l)
L2 U2 MB2 WL2 MB WL2 MB U2 R2 MF SL2 MB'

Centers 4: Bloc (u, f, d, l) = (u, f) (u, d, l)
MR' WD R2 WU MR ML WU' R2 WD' ML' L2 U2 MB2 WL2 MB WL2 MB U2 R2 MF SL2 MB'

Double Python (74 moves)

@ Walter
Here are short additional algorithms for permuting blocs of 4 centers on a 4x4x4 cube:
1- 4 Big Dots: (4c)
(d, f, u, b)
[WU, WF2 WU MR[

(u, f, d, b)
[MR, WU2 MR2 WF2[

2- 6 Big Dots: 2(3c)
(d, f, r) (l, u, b)
[WR, WU]

3- 6 Big Dots: (2c) (4c)
(d, u) (l, f, r, b)
[WR2, MU MF MB]

4- 6 Big Dots: (6c)
(d, f, l, u, b, r)
[NR2, WU2] [WR, WU]

(u, f, r, d, b, l)
[WR WF2, WU' ML2]

5- 2 Big Dots: (2c)
(u, f)
MR' WD R2 WU MR ML WU' R2 WD' ML'
This last one is shorter than that of the site.

@Glazik: This would save a few more turns: U [ MF2 , MR2 ] U- (6 instead of 10 turns)

Maybe you achieved cancellations with yours

Per

The 'Centers only' pattern is given below:
Double Python - Centers only

Before solving centers on the U/D faces, we need to build 2 blocks of 4 centers of the same color. There are 2 solutions:
Sol1: U [MF2 , MR2] U' - 6 m - (your proposal)
Sol2: U [MB MR' MU, MR2] U' - 10 m - (present solution)

By applying each algorithm to the 'Centers only' alg, it can be seen that Sol1 won't build uniform blocks on U/D, whereas Sol2 will. This means that distinct centers are permuted, even though their color is the same. Anyway moves in U can be cancelled by adding the alg to the already existing 'Edges only' alg.

I think the main problem with solving the 'Centers only' pattern is to find a short alg for these 4 permuted blocks: (u, f, d, l).

There may also be another way of solving the entire pattern by pairing up some edges with centers, so that fewer centers would remain to be solved. Here are a few algs:
TU [ML', TU L TU'] TU'
TU [TU R TU', MR] TU'
TD [MF', TD F TD'] TD'
TD [TD B TD', MB] TD'

@Glazik: Hmmm ... is this useful?? : U WR- N2D2 WR U2 WR- N2D2 WR U (9 turns)

Per

@ Per

The 9-mover gives a 'butterfly-like' pattern on faces U and D.
The 2 solutions can be compared below:
Double Python -- Centers only + U WR' MD2 WR U2 WR' MD2 WR U (9 m)
Double Python -- Centers only + U MB MR' MU MR2 MU' MR MB' MR2 U' (10 m)

Hmm. Seems you are blindly applying my suggested algorithms. You have to rearrange the steps, possibly use inverses or whatever ...

When i get the time i will investigate

Per

I found a way to save 4 more moves.

Super Opposed Edge rings:
MR WD2 MR MF WD2 MF (MD WF2)2
M3F2 M3R2 M3D2 (13 btm)

Thanks for the great algorithms!



Note that in order to get a correct back face the algorithm should be modified like this:

Double Python - Centers only:
MB SR2 MF' R2 U2 MB' WR2 MB' WR2 MB2 U2 L2
ML WD R2 WD' MR' ML' WD R2 WD' MR
WD WR2 WD' WR2
B2 (R2 MU' (MB2 TR2 MU' TR2 MB2 TR2 MU TR2) MU R2
U (MR2 MB MR' MU MR2 MU' MR MB') U') B2 (50 btm)


I replaced part 4 and 5 with a shorter solution:

Double Python - Centers only:
MB SR2 MF' R2 U2 MB' WR2 MB' WR2 MB2 U2 L2
ML WD R2 WD' MR' ML' WD R2 WD' MR
WD WR2 WD' WR2
MR2 U' ML MF U MR2 U' MF' ML' U' MU MR U2 MB2 U2 MR' U2 MB2 MU' (45 btm, or 44 actually)


Maybe a short alogrihtm can be found which does part 1 thru 3 at once.
This section cycles blocs of 4 centers in the following order:
up -> right -> left -> down -> back -> front

@ Walter:

I combined the parts 1-3 of the centers only like so:

double python - partial centers only

I solved steps 1-3 and reversed it. First i did a cycle WL WU WR WD

then remaining 4 faces with conjugation :
N2R- D2 N2R N2L D2 N2L-
WR2 N2D2 WF2 N2U WF2 N2D2 WR2 N2U-
N2L D2 N2L- N2R- D2 N2R

And yes i'm sure shorter is still possible ...

Per

Edit: Slightly improved again:

Double python - partial centers only.

MR2 U- ML MF U MR2 U- MF- ML- U- MU MR U2 MB2 U2 MR- U2 MB2 MU- can be replaced with
F L N2D D N2F WR2 N2F2 WR2 N2F D- N2D- L- F- (13 turns)

Then the whole sequence for centers only becomes:

Double python - Centers only.

Now it's only 37 turns. Yay !!

Per

And the complete improved pattern:

Double python.

@ Per

Awesome work! I am very impressed how you improved this algorithm!

I just did some minor cancellations to bring it further down to a lenght of 61 moves:

Double Python
U2 R2 (MD2 B2 MU' B2 MU R2 MD' R2 (B2 MD')2) R'
U' F L2 F' MR ML F L2 F' U R' U' MR' ML' U'
MR F2 MR2 D2 MR
MU WR2 MD2 WF2 MU' WF2 MD2 WR2
MR' D2 MR2 F2 ML' SF WD' B
L TD (MF WR2 MF2 WR2 MF) TD' L' F' (61 btm)

And here comes the other very similar looking version:

Double Python 2
U R2 F' WD B WD2 B' WD F R2
ML2 WD' ML WD ML2 WD' ML T3U'
F2 (MD' L2)2 F2 MD' F2 MU L2 MU' L2 MD2 F2
ML B2 ML2 D2 ML
MU WL2 MD2 WB2 MU' WB2 MD2 WL2
ML' D2 ML2 MF MB B2 WD2 MF' MB' ML' WD2
F L TD (MF WR2 MF2 WR2 MF) TD' L' F' (67 btm)


The algorithm above can be transformed into:

Double Python 3
D F2 R' WD' L WD2 L' WD' R F2
MB2 WD MB WD' MB2 WD MB T3D'
R2 (MU' B2)2 R2 MU' R2 MD B2 MD' B2 MU2 R2
MB L2 MB2 U2 MB
MD WF2 MU2 WR2 MD' WR2 MU2 WF2
MB' U2 MB2 MR ML L2 WD2 MR' ML' MB' WD2
R B TU (MR WF2 MR2 WF2 MR) TU' B' R' (67 btm)

Note, that 'Double Python 3' and 'Double Python 1' have exchanged colors.

Oh no!! More optimisation work

Per

I started out with a good idea. Once again the outcome was not so striking as i had expected ...

Gridlock.

and a variety

Gridlock with centers.

I'm very positive better sequences can easily be found

Per

By scaling a short 5-cycle of blocks of centers from a 4x4x4 cube, 5 large rings can be patterned on a 6x6x6 cube (not optimized yet).

(u,r,b,l,f) – 16 moves – 4x4x4 cube:
WD2 WL MF' WL' U2 MF U2 MF' WD2 WL' MF WL U2 MF' U2 MF

Scale to 6x6x6 cube:
WD2 WL VF' WL' U2 VF U2 VF' WD2 WL' VF WL U2 VF' U2 VF
MF' U2 MF U2 M2R MF' M2R' M2U2 MF U2 MF' U2 M2R' MF M2R M2U2

Algorithm (31 moves)
WD2 WL VF' WL' U2 VF U2 VF' WD2 WL' VF WL U2 VF' U2 NF U2 MF U2 M2R MF' M2R' M2U2 MF U2 MF' U2 M2R' MF M2R M2U2

5 Large Rings (Order 5)

Hi!

I improved the 5 Large Rings.

First i solved Glazik's patterns like this:

WR- WU WR WU- M2U M2R- M2U- M2R, leaving 4 rings as 2 2-cycles.
Those can be solved with a quite simple conjugation:
VR- D2 VR2 F2 VR-
WR2 WU WR2 WU- M2R2 M2U M2R2 M2U-
VR F2 VR2 D2 VR

Then finally i reversed all of that - 5 turns saved

On 4x4x4 i would need 18 turns (4+5+4+5), the saving only reveals itself on 6x6x6 (no double setup).

Per

5-cycles of (slotted) blocks of centers can also be applied to odd-order cubes, provided true centers are left unchanged, for parity reasons. Notice that 5 blocks can be permuted either as (2c)(3c) or (5c). In this post, only 5-cycles are considered.

By scaling up this short (5c) algorithm from a 4x4x4 cube, patterns can easily be obtained on 5x and 7x cubes:
(f,l,r,d,u) (15 m)
]WR WD, MR' D2 ML MR D2 ML'[ = WR WD MR' D2 ML MR D2 MR' WD' MR D2 ML' MR' D2 ML

1-
NL' NR ND NU' NR' D2 NL NR D2 NR' NU ND' NR D2 NL' NR' D2 NL
5 Slotted Dots – Order 5 – 5x5x5 Cube

2-
VL' VR VD VU' VR' D2 VL VR D2 VR' VU VD' VR D2 VL' VR' D2 VL
5 Slotted Dots – Order 5 – 7x7x7 Cube

3-
VL' VR VD VU' VR' D2 VL VR D2 VR' VU VD' VR D2 VL' VR' D2 VL
N3L' D2 N3R N3L D2 N3R' N3D N3U' N3R D2 N3R' N3L' D2 N3R N3U N3D' N3R' N3L
5 Slotted Rings – Order 5 – 7x7x7 Cube

EDIT: from his last post, Per may well find shorter algs again

Here is an easier one:

2 Large Rings.

Per

I pass: My technique wont work well on those Excellent patterns Glazik!!

Per

One can do Gridlock only on solely 3 faces also:

Half Gridlocked.

Breakdown:
1. TR [F N2U F-,U2] TR-

2. U- B- (*) N2D R2 N2D R2 F2 N2D F2 N2U- R2 N2U R2 N2D2 B U

3. (*) = N2D B- U- B N2D B- U B N2D

Better can surely be found. This was my first attempt!

Per

I improved my previous pattern.

1. U R (*) N2B U2 N2B U2 R2 N2B R2 N2F- U2 N2F U2 N2B2 R- U- (parity)
2. (*) R- F R N2B- R- F- R N2B (insertion)
3. N2B R N2B- R- F R N2B R- F- N2B- (appended)

Half Grid-Locked.

Small improvement. Down from 34 to 31 turns. This one is quite tricky ...

Per

I extended the Half Grid-Locked with some center whirl effects.

Half Grid-Locked Whirls.

I managed cancellation on my first center cycle insertion

Per

2 rings can also be done on 5x5x5.

2 Large Rings.

This should generalize to higher order odd sized cubes ...

Per

A more straight forward way: (saves 1 turn)
1. N2L- WU2 N2L U2 N2L- WU2 N2L
2. N2R WU2 N2R- U2 N2R WU2 N2R-
3. MF WU- MF- U MF WU MF- U-

2 Large Rings.

And finally a more clever way:
2 Large Rings. (saves 4 turns)

(end edit)

More rings patterns:

4 Rings (+/- 90).

4 Rings (slice 4-cycle).

Per