A complex number represents a rotation and a scaling and translation of another complex number.

That is about as physical as it gets in mathematics.

Given two complex numbers, `a+b`

is translating `a`

by `b`

.

And `a*b`

is rotating `a`

by the angle of `b`

, then scaling the result by the magnitude of `b`

.

A strange thing happens because the same value `b`

represents both a scaling/rotation operation, and a translation operation, on another complex number.

So how do we inspire that physically?

If we have:

```
(a + b)*c
```

this is obviously "start with `a`

. Move by `b`

. Then rotate/scale based on `c`

. The algebra lets us break this apart:

```
a*c + b*c
```

which is really neat. There is a whole **pile** of things you can align this algebraic manipulation to physical operations here.

The next bit is a bit strange:

```
a * (b + c)
```

what happens when you *add* complex rotate-and-scale operations? Well, algebra tells us this is:

```
a*b + a*c
```

the operation `b+c`

becomes "what if you took something, rotated it scaled by `b`

and then by `c`

, then added the result".

This is strange operation. But you know what isn't a strange operation?

```
(b * lambda + c * (1-lambda))
```

This is called an affine combination of `b`

and `c`

.

So we have two different rotation/scales, `b`

and `c`

. And we want to *interpolate* between them smoothly.

Then

```
a* (b * lambda + c * (1-lambda))
```

as lambda goes from 0 to 1 gives us the result of transforming `a`

first by `b`

, then finally by `c`

, and having a smooth transformation in between.

Also

```
a * (b * c)
```

is rotate/scale `a`

by `b`

, then by `c`

. `b*c`

is the combination of the two rotations/scales in one value.

So applying the same rotation/scale twice would be:

```
a * (b*b)
```

or

```
a * b^2
```

which means that if c^2 = b, then

```
a*c^2 = a*b
```

or, `c`

is the operation that if you do twice, you get `b`

.

On the real line there are two different operations such that if you do either one twice, you get 4. They are `-2`

and `2`

. The same holds in the complex numbers.

Of interest is

```
a * c^3
```

because on the real line, there is only one scale factor that can get `8`

if you do it 3 times. But in the complex numbers *there are 3*.

To see this, look at scaling by 1. On the real line, there are two scale/rotates that reach 1 by applying twice -- "-1" and "1". These correspond to the complex numbers `1 e^0`

and `1 e^(pi i)`

-- no scale, no rotation, and no-scale, half rotation.

If you do half rotation twice, you get a full rotation, ie nothing.

How about the cube root of 1? Something you do 3 times that is a scale or rotation, and afterwards you end up being back where you started.