# ZZ speedcubing system

Author: Michal Hordecki mhordecki@gmail.com http://www.emsee.110mb.com/Speedcubing 2008-08-13 1.1

Abstract

This document descibes the basic principles of ZZ speedcubing system and it's common variations.

ZZ was developed in 2006 by Zbigniew Zborowski, the co-inventor of the acclaimed Z-B speedcubing system. ZZ is a revolutionary approach - it focues not only on move count (which varies, from 40's to 50's, depending on variation), but also on move ergonomy, which allow one to reach even better TPS (Turn Per Second) rate than with classic systems, such as Fridrich or Petrus).

Despite it's obvious potential, ZZ speedcubing system is unknown in mainstream speedcubing community, hence this document, aimed primarily at experienced speedcubers.

# Changelog

1.2
1.1
Lots of bugfixes, changed order of the chapters. ~14% more content.
1.0
Initial release

# Terminology

F2L
Phase that encompasses solving first two layers of the cube - i.e.
1L
First layer
2L
Second layer
LL
Last layer
OLL
Orienting all pieces of LL, without respect to their permutation.
PLL
Permuting all pieces of LL, while preserving their orientation.
EPLL
Permuting all edges of LL, while preserving all other pieces.
n-look LL:
Solving LL in n steps.
COLL
Orienting and permuting all corners of LL, while preserving LL edge orientation.

# Searching for Fridrich's succesor

With top speedcubers pushing Fridrich method to it's ultimate limits, efforts were made to develop better approach. Let's analyze the problem.

Standard solve using Fridrich method comes as follows:

F2L:

• Cross - Solving four 1L corners.
• 4 x Slot - Solving one pair of 1L corner and 2L edge.

LL:

• OLL
• PLL

Calculated average move count is 56, and a theoretical time average of 17 seconds. Hovewer, nowadays' speedcubers average sub-12sec. Fridrich is the most popular method as of today, it was therefore developed further. Usually, improvements aim at F2L phase (mainly due to non-restrictive state the cube is at that stage) - such as joining first step (cross) with second (first slot), known as XCross, or solving multiple slots at once, known as multislotting.

F2L is a individual matter, so development is mainly focused on LL phase.

Obvious, and ultimate, improvement is to join LL steps into one, called simply LL. Hovewer, trendemous ammount of possible cases (counting in thousands) renders it impractical.

Z-B ([zb]) is one of the possible solutions. It's divided into following phases:

F2L:

• Cross
• 3 x Slot
• Last Slot with LL edge orientation.

LL:

• LL

As you can see, Z-B is a 1-look LL approach with one, vital difference. All LL edges are oriented while solving the last slot. Such action drops possible LL cases to a matter of hundreds (about 500). Hovewer, last slot can no longer be solved intuitively. It's composed of approx. 300 cases.

In Z-B, average move count is nearly 40 - it's therefore so low that it could be used even to FMC.

The only, but critical disadvantage of Z-B is the number of algorithms. While lower than pure 1-look LL, it's still an order of magnitude higher than Fridrich (800 comparing to 80). While individuals are trying to learn Z-B (which takes probably years to learn, yet to master), it wasn't widely adopted. Few inventions, such as VH, were created to aid this, but they weren't successful.

# ZZ - revolutionary approach

ZZ is new speedcubing method, invented by Zbigniew Zborowski (published in [nooks]) in 2006 and polished by Polish speedcubers' community [psf1]. ZZ can be perceived as mix of so-far distinct concepts, such as 1-look LL or blockbuilding F2L. These are present in many modern systems, but were never seen in one system. In fact, term ZZ can mean any of it's incarnations, as it has evolved during it's development. The most popular variants have been described here.

General concepts:

• EOLine is the most characteristic concept of ZZ. Must read if you're going to learn any ZZ variation.
• Blockbuilding consists of author's personal thoughts about blockbuilding - the preferred way of doing ZZF2L.
• Phasing, which is an easy way to influence LL edge permutation in order to do 1-look LL with low number of possible cases.

ZZ variants:

• ZZ-VH is the simplest of ZZ variants. It needs 40 COLL algorithms + 21 standard PLL.
• ZZ-b is the recommended way of doing ZZ, it can be called the 'next level' ZZ.
• ZZ-d is the incomplete , chronologically first ZZ variation, that could be the extremely fast if only the 'missing link' was solved.

Be sure to visit Practical notes section, where I've collected various hints and ideas concerning actual solving.

## EOLine

This step is unseen in any of the mainstream speedcubing methods. It's the characteristic feature of ZZ methods family.

EOLine is the first phase in all ZZ versions. EOLine stands for edge orientation & solving two opposite first layer edges (usually DF and DB). It's a replacement for the classic cross. It's designed to be done completely intuitively, too.

First, it seems that EOLine (EO for edge orientation, Line - for line on the D face) is inferior to the classic Cross approach. We solve only the half of cross this time, and there isn't any visible benefit of EO at this phase of solve. Well...

Nothing's more wrong!

What's so beneficial in edge orientation, anyway? At first, let's answer what "edge orienation" actually is.

I will quote Macky's article ([macky]) on blindfold solving::

```There are twelve edge pieces on a Rubik's Cube.
Since each edge has two stickers, it can be twisted in two ways:
correct and incorrect orientation. We define "correct" orientation
of an edge to be the one that it can reach from the solved state
within the (UDF2B2RL) group*, i.e. without quarter turns on F and
B faces. The other orientations are "incorrect". From this
definition, we can determine the orientation of an edge by (mentally)
moving it to its correct position under this restriction. If the
facelet colors match with the centers, the edge is correctly oriented.
In official attempts we cannot make any moves during memorization.

(...)

Here is one way to process this information quickly:

In U/D layer
# 1. If the piece has a U/D color, correct if this is on U/D, incorrect if on F/B/R/L.
# 2. Otherwise, correct if R/L color is on F/B/R/L, incorrect if on U/D.

In the middle layer
# 3. If the piece has a U/D color, correct if this is on F/B, incorrect if on R/L.
# 4. Otherwise, look at either one of the two stickers and the adjacent
center. If these two colors are same or on opposite sides, correct.
Otherwise, incorrect.
```

First advantage - after EO, we put the cube into <U, D, F2, B2, R, L>-group. But, we also do Line - so we reduce cube to <U, R, L>-group.

The immediate benefit is probably obvious.

F2L using only R, U and L facelets. With no rotation

No rotation simplifies looking ahead, and that combined with increased rate of 3-move cases and 2-gen algorithms (RU for the right side, LU for the opposite) can potentially give it's user an insane speed.

It is possible to do EOCross instead of EOLine. This way, one would end with a state similar from that after Fridrich's first step. Ergonomy is retained - we're still in <R, U, L>-group. In this approach, the main problem is the complexity. In order to achieve successful times, one must plan the whole first step during preinspection. Creating optimal solution for EOCross (or even sub-optimal) in 10 seconds or so can be percieved as making XCross every solve. On the other side, EOLine is generally easier approach, and leaving DR and DL unsolved isn'y so scary in fact that in ZZF2L there aren't slots, there are blocks.

EOLine optimal average move count is calculated as ~6.127, there are 8 move cases and one 9 move case, though.

Exact statistics were made by Grzegorz Ćuczyna::

```0 : 1
1 : 9
2 : 91
3 : 851
4 : 6831
5 : 41703
6 : 130239
7 : 88683
8 : 1927
9 : 1
```

Percentage::

```0 : 0.00037%
1 : 0.00329%
2 : 0.03366%
3 : 0.31479%
4 : 2.52686%
5 : 15.42636%
6 : 48.17671%
7 : 32.80473%
8 : 0.71282%
9 : 0.00037%
```

The 9-move case appears when all 12 edges are flipped, and Line edges are permuted correctly. Shortest approach to solve that is to do B' R F' D' L' U' B' R' D'.

# ZZ-VH

ZZ-VH ([psf3]) is the simplest of all ZZ variants. It affects only F2L, and can be easily expanded into more advanced ZZ-b.

After doing ZZF2L, one ends with standard LL, however all edges are oriented. One of the following approaches are possible:

• Do simplified Fridrich from here. Probably the easiest, cause for majority of speedcubers it does not require additional algorithms.
• VHLL ([vh]), i.e. COLL + EPLL. There are slightly less algorithms than in previous approach. Move count is worse, but the recognition speed is way higher. Also, EPLL is usually very fast.
• Do 1-look LL, namely ZBLL. ZZF2L+ZBLL is called ZZ-a. It's another name is so called 'hardcore variant', as it needs ~500 algorithms.

ZZ-VH, as name suggets, utilizes the second approach.

ZZF2L:

1. EOLine
2. Blockbuilding F2L

VHLL:

1. COLL (Corner permutation & orientation without flippind edges)
2. EPLL (Edge permutation)

Of course, one can do ordinary slot-based F2L rather than blockbuilding. Given the circumstances, although, blockbuilding is the preferred approach, as it allows to solve remaining cross edges alongside the rest of F2L.

The number of algorithms is quite interesting. COLL yields 40. EPLL consists of only such permutations like U, Z and H. Of course, there's a need for full PLL knowledge just in case of OLL skip. Hovewer, it's still 61, and that's lower than that of Fridrich [1].

# ZZ-b

As for today, ZZ variant-b is the recommended way of ZZ for advanced speedcubers. It was invented as a replacement for ZZ-d due to existence of the 'missing link'.

ZZF2L:

1. EOLine
2. Blockbuilding of one side
3. Finishing F2L + phasing (i.e. permuting two opposite LL edges)

ZZLL:

1. ZZLL - 1-look LL

The main difference lies in so called "phasing". Just when finishing F2L, one must permute two opposite LL edges, usually UF and UB. It takes 2-4 moves on average and can be done on the fly (of course after proper training). Phasing style is individual to each speedcuber, as it depends on F2L techniques. However, you can see basic approach to this problem in Phasing section in Practical notes.

After ZZF2L comes the standard 1-look LL. However, fact of two opposite edges permutted correctly drastically decreases a number of possible LL cases. It's 80 distinct algorithms. When we count inversions and symmetries, it gives us 167 sequences. This is 2x that of Fridrich, but it's still a reasonable number that can be learned and recognized quickly [2].

As the moment of writing, there's one known person using this variant in competition - Zbigniew Zborowski, author of ZZ. However, author of this article is aiming to learn ZZ-b, as he is currently using ZZ-VH.

# ZZ-d

Finally, there's the chronologically first ZZ variation. It's percieved as the fastest ZZ variation (<50 moves on average, and they are mainly 2-generator), but it's incomplete.

ZZ-d is divided into following steps:

F2L:

1. Edge orientation and solving two opposite 1L edges (usually DF and DB)
2. Solving left 2x2x3 block of the F2L with simultaneously reducing the cube to the <R, U>-group.
3. (2-generator) Solving remaining F2L part.

LL:

1. (2-generator) 1-look LL.

As for today, the main problem lies in step number two. Reducing the cube into <R, U>-group mean that, after F2L, one would end with all corners permuted correctly. It's harded that it seems. Of course, there are methods of doing so, but no one has found the way to do it quick (virtually on the fly).

After such F2L, one would end with few LL cases possible - only corner orientation & edge permutation. All algorithms are 2-generator, obviously.

ZZ's move count is outstanding. It's ~47 moves on average (assuming the "missing link" is made in 2 moves - it has been proven that's possible). Fact worth mentioning is that ~27 of them are 2-gen - RU.

# Practical notes

Up to this point ZZ was described only in theory. In this chapter, I will discuss some of practical aspects of ZZ. This chapter is based primarily of the experiences of me and Mateusz Kurek, another ZZ (ZZ-VH, specifically) solver. It's also thought as less formal. This chapter is to be updated frequently, as new ideas and concepts pop out.

To simplify explanations, D will be assumed as the first layer.

## EOLine

This phase is probably the most important one in ZZ, because

1. It appears in every variation, so mastering it is crucial.
2. Given the fact of <R, U, L>-group moves in later phases, EOLine is probably the slowest(in terms of TPS), so it should be as optimal as possible.
3. Bad EO (i.e. missing some flipping edges) can have disastrous effects, cause, when discovered, it puts cuber out of the rhythm, therefore adding seconds to overall time.

For beginner, following distinction is advised: EO + Line - i.e. first do the EO, next solve DF and DB.

Before solving EO, one must learn how to determine orientation for each edge, and to it quick. It is described thoroughly in Macky's tutorial ([macky]) and Speedsolving.com forum ([speed1]). Gilles Roux, while describing his speedcubing method, also describes edge orientation ([roux]). It was also discussed with ZZ's author in [psf2].

When you are able to determine EO quickly, it's time for actual EO solving. You do not need to know any specific algorithms. There is only one rule - F and B moves change orientation of the edges placed on them (also F' / B', but not F2 / B2). So, if one places one flipped (i.e. with wrong orientation) edge on F face and then do F, he will end with all F edges with altered orientation, in this example 3 flipped and one correct.

Standard approach comes as follows::

```When >=4 edges flipped:

Using RULD moves, put 4 flipped edges to either F or B face, and then do F/B.

When exactly 2 edges flipped:

Put only one of the flipped edges on F/B face, then do F/B. You will end then
with 4 misoriented edges. Proceed as with >=4 edges rule.
```

Then do a Line using only RULD moves. It's probably so trivial that there isn't need to explain it.

Of course, when one will become proficient with basic technique, advancement should follow. EO + Line shall become EOLine - just do such EO, than you will end with 0 to 2-move Line. It sounds hard, and it indeed is. It can be as well divided into two stages:

1. Solving EO and Line independently, but predicting DF and DB position after EO during preinspection, therefore making smooth transition between EO and Line.
2. Solving EO and Line simultaneously.

While stage 1 can be trained in matter of months, doing stage 2 consistently would be real feat, as there's no one who is doing it every solve yet.

Getting proficient with EO is only the matter of practice. In first days of ZZ'ing, expect solving EO in 30 seconds or so. Counting flipped edges loudly helps alot. In the process of training, you will see that some patterns do repeat (well, there are only a few hundreds of distinct EO cases). After half a year, finding optimal EO solution will drop to sub-5 seconds.

For ones who wish to train EOLine, [nooks] (section 2.3) provides a good tool. It computes optimal EOLine algorithm for the given scramble.

## Blockbuilding

I completely do not feel as blockbuilding expert, cause I came from Fridrich to ZZ. Blockbuilding half of the F2L in one step and doing it fluently is out of my reach, so I developed another method for doing ZZF2L.

I do not solve 2x2x3 block all at once, but separate it into two phases:

1. Solve 2x2x2 block - i.e. slot + adjacent cross edge.
2. Solve remaining slot.

So, for solving left and right side it gives total of 4 substeps, which i try to mix (for the sake of speed, of course) as much as possible.

When solving 2x2x2 block, I use two approaches:

• If I see c+e pair and it's an easy slot case, I solve it Fridrich-like and then insert along with cross edge. A set of shortcut and not-so-obvious algs can be found in [nooks] (section 2.2.2).
• If I see an c+cross edge pair and it's easy to join them, I do that. Then, place 2L edge on the target facelet. Finally, i join everything and do R2/L2.

Solving remaining slot is the concept already familiar to Fridrich users, so it won't be described here - there are other, brilliant articles on that. Note that you need to modify your algorithms to use only RULD moves.

## VHLL

VHLL consists of 2 substeps - COLL and EPLL.

COLL is basically a corner orientation & permutation without flipping edges. It can be recognized by looking at 4 stickers (it depends which on the orientation case).

COLL algorithms can be found on numerous sites:

These pages do not use recognition by stickers:

As for EPLL, algorithms can be found on virtually any site that teaches Fridrich method.

## Phasing

Here I describe my phasing method. I use simple blockbuilding consisting of 2 blocks and 2 slots. I do phasing while doing last slot (and I do last slot at the end of F2L).

Virtually all of F2L cases end similarly. It is usually something like U R U' R' or R U R' or R' in special cases. Therefore, while doing 4th slot, I recognize phasing situation, and then at the end I apply proper moves.

If you allow AUF after phasing, there are 3 possible LL edges permutation cases for you to recognize.

To simplify explanation, assume that the 4th slot is the DFR+FR pair.

To name each case, I use the following approach:

Execute R U' R' on the solved cube. You will end with easy F2L case. When looking at the front of the cube, you can see three LL edges - one placed in UF, another in UR and the last in FR. By these 3 edges you can recognize phasing situation. At first, notice that within three edges there is always a pair of opposite edges, i.e. UF-UB or UR-UL. I'm recognizing the phasing case by looking where these opposite edges are.

I use 2-letter system: for example x-F means that the opposite edges are placed in FR (x) and UF (F), F-R is UF and UR.

### RUR' case

Setup moves for F2L case
R U' R'
x-F
R U' R' U' R U' R'
x-L
R U2 R' U R U2 R'
F-R
R U R'

### URU'R' case

Setup moves for F2L case
R U R' U'
x-F
U R U' R'
x-L
U2 R U2 R'
L-F
U2 R U' R' U R U2 R'

### R' case

Some algorithms end with this case, you can also encounter this when you get lucky case. It is undesired though, as algorithms are a bit longer this time.

Setup moves for F2L case
R
x-F
U R' U R U2 R'
x-L
R'
F-L
U2 R' U' R U' R'

## ZZLL

ZZLL is a subset of ZBLL, so nothing stops you from using ZB-specific pages- there are a few sources of such algs.

If you want ZZ-specific one, you can use [nooks], section 2.2.3.

Recently, I've computed solutions for all ZZLL cases. Hovewer, my approach was a bit different. In ZB, you recognize which corners you need to swap (easy 4-sticker recognition), then you look at edge case. I'm doing the opposite. When phasing, I recognize whether the remaining two LL edges are correctly permuted or not. Then, I do 4-sticker corner recognition (with extra cases). It's a bit harder at the beginning, but I believe that with decent look-ahead it's superior in the long run.

You can find more at http://www.emsee.110mb.com/Speedcubing/ZZLL/ .

# Example solves

Scramble
R2 F2 L2 F2 U' L2 F2 U F2 U F D2 L' D2 B2 L' R2 U B U' (generated by Cube Explorer)
Misoriented edges:
UF, BR, BL, DF
EOLine
E2 F' E2 B2 Pretty straightforward
Blockbuilding
R' U2 R U' R U2 L U L2 U L' U2 L U' L' Finished the left side. FR & DFR are luckily connected.

Now, different scenarios are possible:

ZZ-b:
U2 R U' R2 U R U R' U R U' R' U' R Phasing wasn't needed, actually.
ZZ-VH:
U' **R'* U' R2 U' R' U' R' U R U2 R' U R* With that R', I've disconnected DR and DBR. If I hadn't done that, I would have end with very ugly F2L case. Luckily, I've got 2-generator LL now. It means that this solve was accidentally also ZZ-d! I swear, It was straightforward solve with random scramble.

# Summary

ZZ is an interesting method. Learning and mastering it is truly rewarding. For example:

• OH - using mainly 2-generator moves simplify movements, and slower TPS allows to do phasing smoothly even without hard training.
• 'Secondary' method - imagine the case you get the scramble with no misoriented edges. It's a perfect occasion to do RUL F2L. Having ZZ as primary method it can give the boost of 25% (one can not only skip EO preinspection, but lookahead way further into ZZF2L).

And, there are areas for improvements, as in every method - Blockbuilding techniques, for a start.

# Footnotes

 [1] It's likely that the absolute number will be bigger. One, searching for optimization, can learn all EPLL, consisting of 8 U cases, 2 Z and 1 H; Hovewer, 61 is the bare minimum.
 [2] Actually, recognizing corrent ZZLL case is no harder than standard COLL. When doing phasing moves, check the permutation of remaining 2 edges (it can be either correct or swapped) and then treat ZZLL like ordinary COLL (using proper algorithm 'set' according to that 2 edges, rotation etc). It seems hard to do these things at once, but it's only a matter of practice.

# Bibliography

Unluckily, all of ZZ-related texts are written in Polish language. That was unevitable, though.

 [nooks] (1, 2, 3, 4) (beware, huge amount of java applets - can crash Firefox, try with Opera or with text-based browser) http:://www.speedcubing.com.pl/nooks_zz.htm