
Checklist to make sure the Greek gift sacrifice will work in a certain position:

0. The opponent has castled kingside.
1. You must have a bishop that can sacrifice itself for the h7/h2 pawn.
2. The pawn must not be defended by any piece other than the king.
3. You must have a knight that can hop into the g5/g4 square that can give a check in case the king takes the bishop.
4. The g5/g4 square must be protected. Otherwise the knight can just be taken by the opponent's queen.
5. You must have a queen that can land itself in h5/h4 to threaten checkmate. The only way to prevent checkmate is for the opponent is to give up the queen for the knight, or to protect the h7/h2 square.
6. The opponent must not have a way to protect the h7/h2 square directly with a bishop on the h7-b1/h2-b8 diagonal. **This is the condition that is forgotten the most.**

An example of a position where the greek gift sacrifice is possible:<br /><br />
![greek gift](/img/weblog/greek-gift.png)

## Links

- [Greek gift sacrifice - Wikipedia](https://en.wikipedia.org/wiki/Greek_gift_sacrifice)
- [Greek Gift - lichess.org/practice](https://lichess.org/practice/intermediate-tactics/greek-gift/s5pLU7Of/uCkLsFs1)
- [Back to 3000 Elo chess speedrun - Daniel Naroditsky](https://www.youtube.com/watch?v=wdHXvOBC8bw&t=1096s)
- [GM Naroditsky's Chess.com article](https://www.chess.com/article/view/the-greek-gift-sacrifice-lives-on)


Essential conditions for a Greek gift sacrifice

[Top]

Links


I know, this is a completely worthless thing to memorize. Even [NASA](https://www.jpl.nasa.gov/edu/news/2016/3/16/how-many-decimals-of-pi-do-we-really-need/) uses a mere 15 digits of Pi for their highest precision calculations, and according to them, just 38 digits of Pi are sufficient to calculate the circumference of the entire observable universe to an accuracy equal to the diameter of a hydrogen atom. But hear me out, this is a trick that's worth learning if you want to impress your friends, especially considering how easy it is to learn!

The technique is a standard method used by professional memory champions. So if you learn it for this trick, you can use it for many other use cases, like memorizing phone numbers and even the order of a shuffled deck of cards. It's called "**major system**". This allows you to map each digit into a distinct sound and construct mnemonics that are easy to remember. See the table below:

| Numeral | Associated letters |
| ------- | ------------------ |
| 1       | t, d               |
| 2       | n                  |
| 3       | m                  |
| 4       | r                  |
| 5       | l                  |
| 6       | j, sh, ch, soft g  |
| 7       | k, hard g, hard c  |
| 8       | f, v, ph           |
| 9       | p, b               |
| 0       | z, s, soft c       |

Let's look at an example. Say you want to remember the number 42. Since it maps to [r, n], you can choose any word that has these consonant sounds like _rain_, _run_, or _ruin_. Similarly, 620 could be _jeans_, _Jonas_, or _chains_. An important property of this system is that although a number can be converted into many words, a word can be translated only into a single number.

Now let's get to the good stuff. Try to remember the following sentence:

> **My turtle Pancho will, my love, pick up my new mover, Ginger.**

Done? Congratulations, you now know the first **twenty-four** digits of Pi! Here's how it works. If you map the consonant sounds in that sentence back to the digits from the table, you get the following:

```plaintext
My turtle Pancho will, my love, pick up my new mover, Ginger.
3  1415   926    5     3  58    97   9  3  2   384    6264
```

Let's go a bit further. Add these sentences to the previous one and you've got the first **sixty** digits.

```plaintext
My movie monkey plays in a favorite bucket.
3  38    327    950   2    8841     971

Ship my puppy Michael to Sullivan’s backrubber.
69   3  99    375     1  05820      97494
```

Finally, let's crank it up to a **hundred** digits.

```plaintext
A really open music video cheers Jenny F. Jones.
  45     92   307   81    640    62    8  620

Have a baby fish knife so Marvin will marinate the goosechick.
8      99   86   28    0  3482   5    3421     1   7067
```

Here are all the sentences written together:

> **My turtle Pancho will, my love, pick up my new mover, Ginger. My movie monkey plays in a favorite bucket. Ship my puppy Michael to Sullivan’s backrubber. A really open music video cheers Jenny F. Jones. Have a baby fish knife so Marvin will marinate the goosechick.**

## Further reading

By the way, I learned this trick from [Prof. Arthur Benjamin's](https://www.youtube.com/watch?v=e4PTvXtz4GM) excellent book [Secrets of Mental Math](https://www.goodreads.com/book/show/83585.Secrets_of_Mental_Math). This book is full of mental math techniques and I highly recommend it. Here are some other links of interest:

- [Mnemonic major system - Wikipedia](https://en.wikipedia.org/wiki/Mnemonic_major_system)
- [major-system.info](https://major-system.info/en/) - Major system mnemonic database and converter.
- [Piphilology - Wikipedia](https://en.wikipedia.org/wiki/Piphilology)


How to remember 100 digits of Pi, easily


In this guide, I will explain how 4-look last layer (4LLL) in CFOP works and provide the best algs and recommendations that will help to learn the full set later down the road.

Basically, the idea is to solve the last layer in no more than 4 steps. First you orient the last layer using a maximum of 2 algs and then permute the last layer using a max of 2 algs:

1. Edge Orientation (3 algs)
2. Corner Orientation (7 algs)
3. Corner Permutation (2 algs)
4. Edge Permutation (4 algs)

The total number of algs required for 4-look last layer is 10+6 = 16 whereas full OLL and PLL consist of a total of 57+21 = 78 algs. For beginners, this makes it a lot less intimidating and a lot more sense to learn 4-look LL first.

## 2-look OLL (10 algs)

**Steps**:

1. Orient the edges using one of 3 algs
2. Orient the corners using one of 7 algs

After F2L, there are 3 cases (excluding the one where all 4 edges are already oriented) that you can get:

- I shape (2 opposite edges oriented)
- L shape (2 adjacent edges oriented)
- Dot (No edges oriented)

| Cases                                                                  | Algs                                                                                             | Notes    |
| ---------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | -------- |
| ![45](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/45.svg) | <ul><li>F (R U R' U') F'</li></ul>                                                               | OLL 45   |
| ![44](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/44.svg) | <ul><li>f (R U R' U') f'</li><li>y2 F (U R U' R') F'</li></ul>                                   | P/OLL 44 |
| ![2](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/2.svg)   | <ul><li>F (R U R' U') F' f (R U R' U') f'</li><li>F (R U R' U') F' U2 F (U R U' R') F'</li></ul> | OLL 2    |

Instead of using specifically OLL 45/44/2 algs, you could use one of many algs for cases that have I shape (27 OLLs), L shape (15 OLLs) and a Dot (8 OLLs) in them respectively. These algs are usually recommended because they are the easist to learn.

After the edges are correctly oriented, you can get one of the following 7 cases. I highly recommend learning alternative algs for more common cases like Sune and Antisune because a lot of OLLs have variations of Sune, Antisune and their mirrors in them. This will make it easier to learn full OLL.

| Cases                                                                  | Algs                                                                                                                    | Notes                    |
| ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| ![27](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/27.svg) | <ul><li>(R U R' U R U2 R')</li><li>y' R' U2 R U R' U R</li></ul>                                                        | Sune/OLL 27              |
| ![26](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/26.svg) | <ul><li>(R U2 R' U' R U' R')</li><li>y' R' U' R U' R' U2 R</li></ul>                                                    | Antisune/OLL 26          |
| ![23](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/23.svg) | <ul><li>R2 D (R' U2 R) D' (R' U2 R')</li><li>y2 R2 D' (R U2 R') D (R U2 R)</li></ul>                                    | U/OLL 23                 |
| ![24](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/24.svg) | <ul><li>(r U R' U') (r' F R F')</li><li>y (R U R D) (R' U' R D') R2</li></ul>                                           | T/OLL 24                 |
| ![25](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/25.svg) | <ul><li>y F' (r U R' U') r' F R</li></ul>                                                                               | L/Bowtie/OLL 25          |
| ![22](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/22.svg) | <ul><li>R U2' (R2' U') (R2 U') R2' U2' R</li></ul>                                                                      | Pi/Air Jeff/Bruno/OLL 22 |
| ![21](https://github.com/rsapkf/20/raw/main/3x3/cfop/oll/svg/21.svg) | <ul><li>(R U2 R') (U' R U R') (U' R U' R')</li><li>y (R U R' U) (R U' R' U) R U2 R'</li><li>F (R U R' U')3 F'</li></ul> | H/OLL 21                 |

## 2-look PLL (6 algs)

**Steps**:

1. Permute the corners using one of 2 algs
2. Permute the edges using one of 4 algs

When you are done with OLL, there are broadly 2 cases (excluding the one where all 4 corners are already permuted) that can appear:

- Headlights (One set of adjacent corners need to be swapped)

  Put the headlights on the left and apply T Perm.

- No headlights (One set of diagonal corners need to be swapped)

  Apply Y/Nb Perm from any angle.

Remember, instead of T and Y/Nb perms, any other algorithm that swaps one set of adjacent corners (Ra, Rb, Ja, Jb, F) or diagonal corners (Na, V) while swapping one set of edges can be used respectively. Since T and Y/Nb perms are the easiest to learn, these are usually recommended.

| Cases                                                                | Algs                                                                                                                 | Notes     |
| -------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- | --------- |
| ![T](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/T.svg) | <ul><li>(R U R' U') (R' F R2 U') R' U' (R U R' F')</li></ul>                                                         | T Perm    |
| ![Y](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Y.svg) | <ul><li>F (R U' R' U') (R U R' F') (R U R' U') (R' F R F')</li><li>(R' U L' U2 R U' L) (R' U L' U2 R U' L)</li></ul> | Y/Nb Perm |

After permuting the corners, apply one of these 4 algs to finally solve the cube:

| Cases                                                                  | Algs                                                                                                                              | Notes   |
| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------- |
| ![Ub](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ub.svg) | <ul><li>R2 U (R U R' U') R' U' (R' U R')</li><li>y2 (R' U R' U') R' U' (R' U R U) R2</li></ul>                                    | Ub Perm |
| ![Ua](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Ua.svg) | <ul><li>(R U' R U) R U (R U' R' U') R2</li><li>L2 U' (L' U' L U) L U (L U' L)</li><li>y2 (R2 U' R' U') R U R U (R U' R)</li></ul> | Ua Perm |
| ![H](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/H.svg)   | <ul><li>(M2 U M2) U2 (M2 U M2)</li></ul>                                                                                          | H Perm  |
| ![Z](https://github.com/rsapkf/20/raw/main/3x3/cfop/pll/svg/Z.svg)   | <ul><li>(M2 U M2 U) (M' U2) (M2 U2 M')</li><li>y/y' (M2 U' M2 U') (M' U2) (M2 U2 M')</li></ul>                                    | Z Perm  |

Grok these algs and with good fingertricks, hardware, and decent lookahead during F2L, it's actually possible to be sub 30 on the 3x3.

## 3-look last layer

If you have learned 4LLL, the transition to learning the full set of algs for 2LLL is not as easy. It is recommended to learn full PLL first, then gradually pickup the remaining OLLs. This phase is known as "3LLL" or "3-look last layer". You would have to learn at least 10+21=31 algorithms to be able to solve the last layer in at most 3 algs.

## Further reading

- [CubeSkills - 4 Look Last Layer Algorithms](https://www.cubeskills.com/uploads/pdf/tutorials/4-look-last-layer.pdf)
