I now resume the thread of spotting multiples of numbers easily. Thanks to the way positional notation lets us write out numbers as some multiple of our base, which is so nearly always ten it takes some effort to show where it’s not, it’s easy to spot whether a number is a multiple of that base, or some factor of the base, just by looking at the last digit. And if we’re interested in factors of some whole power of the base, of the ten squared which is a hundred, or the ten cubed which is a thousand, or so, we can find all we want to know just by looking at the last two or last three or last or-so digits.

Sadly, three and nine don’t go into ten, and never go into any power of ten either. Six and seven won’t either, although that exhausts the numbers below ten which don’t go into any power of ten. Of course, we also have the unpleasant point that eleven won’t go into a hundred or thousand or ten-thousand or more, and so won’t many other numbers we’d like.

If we didn’t have to use base ten, if we could use base nine, then we could get the benefits of instantly recognizing multiples of three or nine that we get for multiples of five or ten. If the digits of a number are some strand *R* finished off with an *a*, then the number written as *Ra* means the number gotten by multiplying nine by *R* and adding to that *a*. The whole strand will be divisible by nine whenever *a* is, which is to say when *a* is zero; and the whole strand will be divisible by three when *a* is, that is, when *a* is zero, three, or six.

It’s not hard to change a number from one base to another. At least it’s not hard to change a whole number; I admit I never got comfortable changing decimals to another base, but I’ve also been able to rationalize away all my motivations to get comfortable with that. One valid procedure for getting the base nine — or any base — representation of a number is almost designed to be a basic computer programming problem. Divide the original number by your new base as integers, which gives you a quotient and a remainder. Now divide that quotient by the new base, which yields a second quotient and a second remainder. Next divide the second quotient by the new base again, giving you a third quotient and third remainder, and so on, until you finally reach a quotient of zero and a remainder of something smaller than the new base. Read off the remainders you got, in reverse order: the last remainder, the next-to-last remainder, et cetera, ending with the third remainder, second remainder, and original remainder. That’s the number written in the new base.

This is a perfectly valid method which gives us the interesting information of whether a whole number can be evenly divided by whatever makes up our new base, the beauty of which is only marred by it being a stupid way to find out whether the number is divisible by the new base. For one, it requires doing a lot of work that isn’t necessary: if the first remainder is anything other than zero, the number isn’t divisible by the new base anyway, so working out the rest is pointless. For another, while it puts our number into a form we can read information off of easily, it requires doing the hard work of actual division to get there. The point was to avoid stuff where we had to actually divide. The only good reason to convert a number into a new base is that you’re a mathematically skilled elementary school student whose teacher needs to keep you occupied while the more needy students are tended.

We can salvage things, though. What makes a base-nine number convenient for spotting multiples of nine (or three) is that the base-nine-written number *Ra* is nine times *R* plus *a*. And ten has got the little-mentioned property of being just one more than nine.

I’ll get back to the general case in a moment, but first, think about the two-digit, base-ten, number written as *ba*. This is ten times *b* plus *a*. But ten is equal to nine plus one, and we don’t seem to be doing anything outrageous if we replace something with whatever it equals. So change ten times *b* into nine-plus-one times *b*.

This means ten times *b* plus *a* has to equal nine-plus-one times *b* plus *a*. And that’s the same as nine times *b* plus *b* plus *a*. That’s nine times something plus *b* plus *a*. It’s almost as good as the base nine representation: if *b* plus *a* is divisible by three or by nine, so must the entire original number, nine times *b* plus *b* plus *a*, or what we wrote as *ba*.

A hundred, similarly, is equal to ninety-nine plus one. So the three-digit, base-ten, number *cba* is a hundred times *c* plus ten times *b* plus *a*. And that’s ninety-nine times *c* plus *c* plus nine times *b* plus *b* plus *a*. Ninety-nine is a multiple of nine (and of three), so, this whole number is nine times something plus *c* plus *b* plus *a* and we can read the multiples of three and nine off that last bit.

By the time we finish imagining a four-digit number and noticing that a thousand is nine-hunded-ninety-nine plus one and that’s a multiple of nine plus one, we’re convinced that this old trick of telling whether a number is divisible by three or nine by adding up its digits is finally justified. We’ve seen why we can do that.

It doesn’t quite help us with multiples of seven, though, or seventeen. Wouldn’t it be nice if it did?

## 2 thoughts on “A Quick Impersonation Of Base Nine”