by Richard Taylor : 2019-02-23

When people talk about "the inverse scramble" for FMC they mean the trivial inverse of the scramble. This is what you get when you reverse the order of the scramble and invert each of the individual turns.

`inverse( R U' F ) = F' U R'`

You can see how this is an inverse if you write the inverse after the scramble and group moves together from the middle outwards. Each pair of moves cancels, leaving the identity, which is an "algorithm" that has no effect.

`(R (U' (F F') U) R') = 1`

Usually the identity is written as a capital "I" but that may be a bit confusing in an article about "Inverse Scramble" so I will use the number "1" as an alternative for the identity. This comes from thinking of algorithms as multiplying each other, so 1 is the number that does not change anything.

`R 1 = 1 R = R`

There are obviously other inverses of the scramble. Those are what we call solutions and what we are looking to find.

The purist in me thinks that using the Inverse Scramble is against the spirit of FMC. In an ideal world you wouldn't get to see the scramble at all, you would just get a scrambled cube to solve. But that would not be a very practical event - you would either have to be very careful to write down every move you made - or have lots of cubes scrambled the same way - or have "floating scramblers" who could rescramble cubes on demand using the "secret" scramble.

So, on balance, the solvers need to have the scramble. And the pragmatist in me thinks that you play the game as well as the rules allow. If the inverse scramble can give you a better result than the "normal" scramble, then why not use it.

How can the inverse scramble help us solve the normal scramble? Well, if the inverse scramble is S' and we find a sequence of moves A that solves it, then we know:

`S' A = 1`

Applying the same moves before and after each side of the equation,

`S (S' A) A' = S (1) A'`

Gives

`1 = S A'`

So if A is a solution to the inverse scramble, then A' is a solution to the normal scramble.

And why would we want to use the inverse scramble? Well, it might just be easier to work with using the techniques we know. For example,

```
# SCRAMBLE="L2 D' B2 U2 F2 R2 D R2 U' B2 L U' B2 R' U2 R' D B U R"
#
# bin/block222 "${SCRAMBLE}"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Solving time: 0.149369 seconds.
Solutions:
B' L U2 B2 R
B L2 F2 L2 D2
B L F2 L' D2
D2 L' R' D' R
L2 F2 L2 B D2
L F2 L' B D2
```

The shortest 2x2x2 block on the normal scramble is 5 moves.

```
# INVERSE="R' U' B' D' R U2 R B2 U L' B2 U R2 D' R2 F2 U2 B2 D L2"
#
# bin/block222 "${INVERSE}"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Solving time: 0.015249 seconds.
Solutions:
R U F2 L
```

But on the inverse scramble there is a 4 move 2x2x2 block.

You do not have to type in the `INVERSE`

explicitly. There is
a `--inverse`

option that will use the inverse of the scramble on
the command line.

```
# bin/block222 --inverse "${SCRAMBLE}"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Solving time: 0.015249 seconds.
Solutions:
(R U F2 L) L' F2 U' R'
```

Note that with the `--inverse`

option both the solution and
its inverse are printed out. That is because you need to put the inverse
at the front of the scramble if you want to do more work. Because the
inverse is the normal scramble but backwards. So to build a 3x2x2 on this
block using the inverse you would need to use,

```
# bin/block322 --inverse "L' F2 U' R' ${SCRAMBLE}"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Solving time: 0.140285 seconds.
Solutions:
(R' U' R2 B' R) R' B R2 U R
(L U L' B2 U2) U2 B2 L U' L'
```

Whereas if you had typed out the inverse you would put moves on the end instead,

```
# bin/block322 "${INVERSE} R U F2 L"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Solving time: 0.140285 seconds.
Solutions:
R' U' R2 B' R
L U L' B2 U2
```

We will see why the first method is useful in the next section on NISS.

Using the inverse scramble as a simple alternative to the normal scramble, just because it might be easier, is fairly straightforward to understand.

The real power of the inverse comes when you combine it with the normal scramble to do NISS - Normal, Inverse, Scramble Switch.

At first read this can seem like magic, so lets take a careful look at some background first. Here is a cube that has been scrambled and then a 2x2x2 block solved.

Lets call A the set of moves that are the scramble plus the block solution.

What is the effect of A on the pieces that make up the 2x2x2 block? Well, in the solved cube at the start the pieces are solved, and after A the pieces are also solved. So as far as those pieces are concerned A is the identity.

Since the inverse of the identity is also the identity, if we apply the inverse of A to a solved cube then it will also create a 2x2x2 block.

Notice that the other pieces not on the 2x2x2 block are different. That is because for them A and A' do not have the same effect, because they are not the identity.

This gives us a powerful trick. We can take any partial solution A and invert it, then apply it to a solved cube and we will get something that has the same solved pieces, but different (and hopefully better) unsolved pieces.

At this point it is worth noting that we should not think of a scramble and the solution as being a right-to-left process, because both ends are the same thing... so it is more like this,

And since the inverse scramble is the normal scramble "backwards" then you can think of solving the inverse as going round the loop in the opposite direction, like this,

Then, given that we know we can solve a few pieces, invert the solution and go back through the scramble in the opposite direction, and still have the same pieces solved: we can do something like this,

This is the *Normal Inverse Scramble Switch*. We solve a few pieces
going one way, switch, solve a few pieces going the other way, switch, solve
more pieces the other way and so on.

If we switch backwards and forwards between the normal and inverse scramble and eventually get to a solution, by closing the loop, then we will have something like this,

```
P S Q = 1
```

Where P is the inverse of the set of moves we have
applied in the inverse direction and Q is the set of
moves we have applied in the normal direction.
Does that help us with a solution to S?

Let's do a bit of manipulation, adding the same moves before and after each side of the equation,

`P' (P S Q) P = P' (1) P`

`S Q P = 1`

`Q P = S'`

Great. So we can simply move the sequence P from the front to the back and then Q P is a solution to the normal scramble!

Note that we can *only* do this when we have closed the loop and
found a solution. You cannot put the two partial solutions together with an
open loop; it just does not work.

Let's see how this can work in practise. First a straight solution without using the inverse at all:

```
# SCRAMBLE="F2 L' D2 R U2 R' U2 B2 F2 L D2 R2 U L2 F U2 L2 D2 L' D2 L'"
#
# bin/block222 "${SCRAMBLE}"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Solving time: 0.152917 seconds.
Solutions:
F B2 R' D B
# bin/block322 "${SCRAMBLE} F B2 R' D B"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Solving time: 0.139395 seconds.
Solutions:
F2 D2 L' F2 L'
# bin/f2L-1 "${SCRAMBLE} F B2 R' D B F2 D2 L' F2 L'"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Looking for a solution with 6 turns.
INFO: Looking for a solution with 7 turns.
INFO: Solving time: 25.6085 seconds.
Solutions:
D' F2 R' D' R2 F R'
D F' D2 L D L' D'
D F2 D2 F2 R F' R'
R F R2 D2 R F' D2
```

That's 17 moves to F2L-1.

Now lets try the inverse to get a different 2x2x2.

```
# bin/block222 --inverse "${SCRAMBLE}"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Solving time: 0.150026 seconds.
Solutions:
(R' D2 F2 U L2) L2 U' F2 D2 R
(L' B2 U L U') U L' U' B2 L
```

Then switch to normal for a 3x2x2 block.

```
# bin/block322 "U L' U' B2 L ${SCRAMBLE}"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Solving time: 0.144626 seconds.
Solutions:
D R2 D' R' D2
U' R D2 R' U
R' F' R2 F D2
```

And stick with normal for F2L-1.

```
# bin/f2L-1 "U L' U' B2 L ${SCRAMBLE} D R2 D' R' D2"
INFO: Looking for a solution with 1 turns.
INFO: Looking for a solution with 2 turns.
INFO: Looking for a solution with 3 turns.
INFO: Looking for a solution with 4 turns.
INFO: Looking for a solution with 5 turns.
INFO: Looking for a solution with 6 turns.
INFO: Solving time: 1.8515 seconds.
Solutions:
U' B2 U R B R2
```

Which is only 16 moves to F2L-1.

If we can finish off with some more moves Q then our final solution would be

`D R2 D' R' D2 U' B2 U R B R2 Q U L' U' B2 L`

NISS is not a silver bullet. Sometimes it will help, sometimes it wont. In this case it seems to help a bit.

Let's look at Harry Savage's annotated 17 move WR single, which used NISS.

```
Scramble: R' U' F D' L2 B2 R2 B2 U F2 D U F2 R2 F D R2 B L D' B2 R' D' F2 R' U' F
R L' D' L // eo [4/17]
(R2 F') // DR [2/17]
U' R2 D' // 2x2 + sq [3/17]
L2 D' L2 D // EO on all axes + sq[4/17]
F2 U2 F2 L2 // finish [4/17]
Solution: R L' D' L U' R2 D' L2 D' L2 D F2 U2 F2 L2 F R2 [17]
```

It is that second line (R2 F') which is the switch, as indicated by the braces () around the moves.

The way to read this is as follows, writing the original scramble as S,

- Scramble with S
- Apply the moves R L' D' L
- Switch to inverse
- Scramble with L' D L R' S'
- Apply the moves R2 F'
- Switch to normal
- Scramble with F R2 S R L' D' L
- Apply the moves U' R2 D'
- Apply the moves L2 D' L2 D
- Apply the moves F2 U2 F2 L2

The cube was scrambled and solved by the sequence:

`F R2 S R L' D' L U' R2 D' L2 D' L2 D F2 U2 F2 L2`

So we can now drag the moves from before the scramble to the end to get the final solution:

`R L' D' L U' R2 D' L2 D' L2 D F2 U2 F2 L2 F R2`

I think the braces () notation is a nice compact way of writing down a solution that incorporates NISS. It seems to have been first proposed on FMC Solves.

As with all FMC techniques the more you try the more likely you are to hit upon a good solution. So using the inverse scramble, and NISS, is certainly something worth knowing about. And it is not as complicated as it might first seem: if you just think of it as tackling the scramble from both ends.