Sqrt(-1)

[Rule]

...  + 2pi*k*i 

[rabbit]

Hm.

e^(pi)i = -1
e^(pi)i = i^2
0! = 1 = -(i^2)
e^(pi)i = -(0!)
e^(pi)Sqrt(-(0!)) = -(0!)
ln(e^(pi)Sqrt(-(0!))) = ln(-(0!))
(pi)Sqrt(-(0!)) = -ln(0!)
(pi)Sqrt(-(0!)) = -(0)
(pi)i = 0

Somehow I find that wrong... o well.

Um.. ln(-(0!)) != -ln(0!).  ln(-(0!)) = ln(|-(0!)|) + i*arg(-(0!)) = ln(-(0!)) + i*arg(-(0!)) = i*pi

HAH!  I forgot logs don't like negatives...which explains why I confused myself...

[Rule]

Hm.

e^(pi)i = -1
e^(pi)i = i^2
0! = 1 = -(i^2)
e^(pi)i = -(0!)
e^(pi)Sqrt(-(0!)) = -(0!)
ln(e^(pi)Sqrt(-(0!))) = ln(-(0!))
(pi)Sqrt(-(0!)) = -ln(0!)
(pi)Sqrt(-(0!)) = -(0)
(pi)i = 0

Somehow I find that wrong... o well.

Um.. ln(-(0!)) != -ln(0!).  ln(-(0!)) = ln(|-(0!)|) + i*arg(-(0!)) = ln(-(0!)) + i*arg(-(0!)) = i*pi

HAH!  I forgot logs don't like negatives...which explains why I confused myself...

Don't like negatives? 

[Yoni]

ln(e^(pi)Sqrt(-(0!))) = ln(-(0!))
(pi)Sqrt(-(0!)) = -ln(0!)

This transformation is the wrong one.
1) ln(e^pi X) != pi * X, more like pi + ln(X).
2) ln(-X) != -ln(X), more like ln(X) + ln(-1).

And the correct value of ln(-1) is pi*i, of course.

[rabbit]

Don't like negatives? 

I've always been taught that ln(t) is undefined for negative values of t, is this wrong?

[Rule]

z = e^(w)

w = u + iv

z = e^(u)e^(iv)

x + iy = e^(u)e^(iv)

re^(itheta) = e^(u)e^(iv)

r = e^(u)  --->   u = log r
Also,  v = arg (z)

Therefore  log (x+iy) = log(z) =  log (r) + iarg(z) = log(|z|) + iarg(z)

Therefore log(-1) = log(1) + ipi + 2*pi*k*i, where k is any integer.

The principal branch of log (-1) = log(1) + ipi

Although my comment about the "principal branch" may seem trivial, "branch chasing" of multi-valued functions becomes a very important topic in analysis.

[Yoni]

Although, we like to define logarithms unambiguously by imposing the restriction that 0 <= Im[log(z)] < 2*pi.

Edit: Im[], not arg()

[Rule]

Although, we like to define logarithms unambiguously by imposing the restriction that 0 <= Im[log(z)] < 2*pi.

Edit: Im[], not arg()

I think the most often used branch of log(z) is the "Principal Branch,"
Log(z) = log(|z|) + iArg(z),  where Arg(z) (capital 'a') takes the argument of z
from the set (-pi, pi].  I believe this is also a standard in computer science.  One of the reasons we like the argument in (-pi, pi] is because it allows us to define 1-1 analytic inverse trigonometric functions, that take the values we're used to in real analysis. 

But there are problems with just using this branch of log(z); this principal branch has a branch cut along the negative real axis (it isn't analytic there).  If we want to find the derivative of a complex function at z = x < 0, we have to choose another branch of log. 

Also, for various applications, we may want a branch of a function like
(z^2-1)^1/2  analytic outside of the circle |z-i/2| = 1, etc.  An immediate application of this sort of thing is "Keyhole Contour Integration": if you want to find say "Integral(0, 1) x^(alpha-1) * (1-x)^(-alpha) dx"  0< alpha < 1, you'd start by finding a branch of z^(alpha-1)(z-1)^(-alpha) with a cut on the real axis from 0 to 1.

Here are some fairly well written articles on these topics:

Multivalued Functions
Complex Integration
Integration of Multi-valued Functions
Keyhole integration ("residue at infinity")

Not really quite as related, but you might find this interesting after reading the notes titled "Complex Integration":
Tricks for summing series