Most people are taught about complex numbers in the following way:
"We all know that there's no square root of -1. But imagine there were...
This approach has precisely one thing going for it: it roughly parallels the historical development of the subject. Kinda. If you squint at it right. Unfortunately, it's also maximally confusing:
"But Sir/Miss, -1 doesn't have a square root."
"But suppose that it did, and it were called i..."
"But it doesn't."
"But suppose that it did..."
"But it doesn't."
See what I mean? It's a total no-hoper of an approach. Worse, it undermines confidence in the whole edifice of mathematics. If the kids have got the message that maths is meant to make sense, to be consistent, to tell us timeless truths, and now you tell them that it's OK to throw away something that they know to be true, that they can prove to be true, what does that tell them about the epistemological foundations of the whole endeavour? Suddenly you're allowed to just ignore the rules and make up nonsense. No wonder people find complex numbers confusing.

We don't usually teach mathematical topics in the form that they were first discovered, for exactly this reason. New topics are often obscured by our own confusion, and their proper form only comes to light after much hard work to clarify the initial glimpses. The history is fascinating to learn, but best studied once you already understand the relevant mathematics. In this case, it's possible to make the "but imagine it did..." approach rigorous, using Galois' notion of extension fields, but this requires a lot of mathematical sophistication - I covered it in the third year of my undergraduate maths degree, for instance. Fortunately, there's a much easier approach, which ought to be accessible to the lay reader. I'll assume you're comfortable with real numbers like 1, -7.5609, 1/3, sqrt(2) and π.

A complex number is an ordered pair of real numbers ("complex", here, just meaning "made up of more than one thing"). We'll write complex numbers as (1,2) or (5,-7) or (2.34,-9.43). We can add complex numbers by adding the first parts together and then adding the second parts together:
(a, b) + (c, d) = (a+c, b+d)
Remember, a, b, c and d are real numbers, so we already know what "a+c" and "b+d" mean.

Hang on, though, what exactly am I doing here? Did I discover that rule, or did I just make it up? Well, I made it up: I'm saying that when I write a plus symbol between two complex numbers, I mean the operation given above, and I'm going to call that operation "addition of complex numbers" in text, or just "addition" when it's clear from context that I'm not talking about addition of real numbers. We're using language, here: we're setting the relationship between signifiers and signified up so that it benefits us. Just like "a" or "b", "+" is a symbol, and we can choose what meaning we're going to give it, provided we explain that meaning clearly enough for everyone to follow along.

Programmers will recognise this as operator overloading: giving an established symbol an additional meaning so it can be used in a context where it previously had no meaning. They'll also be aware of the biggest pitfall: if you give a symbol a new meaning which doesn't behave like its established meanings, things can get very confusing as the reader's expectations are constantly violated. Fortunately, that isn't the case here, as complex number addition behaves very much like real number addition. For instance, it's associative:
( (a,b) + (c,d) ) + (e,f) = (a+c+e,b+d+f) = (a,b) + ( (c,d) + (e,f) )
it's commutative:
(a,b) + (c,d) = (a+c,b+d) = (c+a,d+b) = (c,d) + (a,b)
it has an identity element, which when added to any number gives you what you started with, like zero for real-number addition:
(a,b) + (0,0) = (a,b) = (0,0) + (a,b)
and each complex number has an inverse, which when added to the number you first thought of gives you that identity
(a,b) + (-a,-b) = (0,0)
These properties mean that you can manipulate sums of complex numbers in exactly the ways that you'd manipulate sums of real numbers, so using the same symbol for complex and real addition saves you mental energy.

I'm going to introduce a rule for multiplying complex numbers, too, though it's not quite so simple:
(a,b) * (c,d) = (a*c - b*d, a*d + b*c)
This definition is also associative:
( (a,b) * (c,d) ) * (e,f)
= (a*c-b*d, a*d+b*c) * (e,f)
= (a*c*e - b*d*e - a*d*f - b*c*f, a*c*f - b*d*f + a*d*e + b*c*e)
= (a*(c*e - d*f) - b*(c*f + d*e), a*(c*f + d*e) + b*(c*e + d*f))
= (a,b) * (c*e - d*f, c*f + d*e)
= (a,b) * ( (c,d) * (e,f) )
commutative:
(a,b) * (c,d)
= (a*c-b*d, a*d+b*c)
= (c*a-d*b, c*b+d*a)
= (c,d) * (a,b)
has an identity element:
(a,b) * (1,0)
= (a*1 - b*0, b*1 + a*0)
= (a,b)
and (apart from (0,0)) every complex number has a multiplicative inverse:
(a,b) * (a/(a^2 + b^2), -b/(a^2 + b^2))
= ((a^2 + b^2)/(a^2 + b^2), (ab - ab)/(a^2 + b^2))
= (1,0)
So it behaves just like real-number multiplication, and we won't cause confusion by using the same symbol and name for both.

It's actually even better than that: we can embed the real numbers into the complex numbers, by associating to each real number x the complex number (x,0), and this embedding respects the addition and multiplication structure of the reals:
(x,0) + (y,0) = (x+y,0)
-(x,0) = (-x,0)
(x,0) * (y,0) = (x*y,0)
(1,0)/(x,0) = (1/x,0)
This embedding even sends the additive and multiplicative identity elements (that's, er, zero and one) to their complex counterparts (0,0) and (1,0). Because the embedding preserves all the structure we care about, it's safe to "abuse notation" and mix real and complex numbers in our expressions, with the understanding that real numbers like 3 are being used as shorthand for their complex embeddings. So, for instance,
3 * (4,5) + 7
really means
(3,0) * (4,5) + (7,0) = (19, 15)
Is this sloppy? Yep. But because of the strong results we've proved above we know that doing this won't cause us to make mistakes, and it's very convenient. Remember, we're trying to make the language work for us, not the other way round.
Now (finally!) we can get to the point of all this. -1 may not have a square root, but (-1,0) does:
(0,1) * (0,1) = (0*0 - 1*1, 1*0 + 0*1) = (-1,0)
No imagination necessary. For historical reasons, mathematicians write the complex number (0,1) as i. This, together with the embedding convention, means that we can write the complex number (a,b) as "a + ib".

Another way of looking at this is that the equation x^2 + 1 = 0 has no solution if x is real, but it does have a solution (in fact, two solutions, i and -i) if x is complex. This is actually a fragment of the beautiful theorem called the Fundamental Theorem of Algebra: if p(x) is any polynomial in x with complex coefficients (ie, a formula that looks like a + bx + cx^2 + dx^3 + ... + zx^n, where a,b,c...z are all complex numbers), then the equation p(x) = 0 has a solution in the complex numbers. We say that the field of complex numbers is algebraically closed, and in fact it's the smallest algebraically closed field into which the real numbers can be faithfully embedded.

We can extend calculus to work on functions of complex numbers, and this leads us to the field of complex analysis and the beautiful theorems of Cauchy, which have applications as far apart as number theory and fluid dynamics. But that's a story for another day.

One might ask if the rules I've chosen above are the only interesting ones. The answer, of course, is no: by choosing the rule
(a,b) * (c,d) = (a*c, a*d + b*c)
we get the dual numbers, which are the clever gadgets behind the magical-seeming trick of automatic differentiation. Or one could go to higher dimensions and consider the quaternions - not so well-behaved as the complex numbers, but they're probably used all over your computer's graphics software. Or the eight-dimensional octonions, or Grassmann numbers, both of interest to theoretical physicists.

Edit: Reddit discussion.
Tags:
• #### PSA: Working Effectively With Legacy Code by Michael Feathers

I am only about a hundred pages into this book, but it had paid for itself after fifty. I wish I'd read it ten years ago. Actually, I wish I'd read…

• #### Srelipmoc ni esruoc tsrif a

If I ever design a first course in compilers, I'll do it backwards: we'll start with code generation, move on to static analysis, then parse a token…

• #### Commuting

Quaffing the last of my quickening cup, I chuck fair Josie, my predatory protégée, behind her ear. Into my knapsack I place fell Destruction, my…

• Post a new comment

#### Error

default userpic

When you submit the form an invisible reCAPTCHA check will be performed.