**Physicist**: Yup!

The “0.999… thing” has been done before, but here’s the idea. When we write 0.9, 0.99, 0.999, 0.9999, etc. we’re writing a sequence of numbers that gets closer and closer to 1. Specifically, if there are N 9’s, then . What this means is that no matter how close you want to get to 1, you can get closer than that with enough 9’s. If the 9’s never end, then the difference between 1 and 0.999… is zero. The way our number system is constructed, this means that “0.999…” and “1” (or even “1.000…”) are one and the same in every respect.

As a quick aside, if you think it’s weird that 1 = 0.999…, then you’re in good company. Literally everyone thinks it’s weird. But be cool. There are no grand truths handed down from on high. The rules of math are like the rules of Monopoly; if you don’t like them you can change them, but you risk the “game” becoming inconsistent or merely no fun.

The same philosophy applies to every base. A good way to understand bases is to first consider what it means to write down a number in a given base. For example:

372.51 = 300 + 70 + 2 + 0.5 + 0.01 = 3×10^{2} + 7×10^{1} + 2×10^{0} + 5×10^{-1} + 1×10^{-2}

As you step to the right along a number, each digit you see is multiplied by a lower power of ten. This is why our number system is called “base 10”. But beyond being convenient to use our fingers to count, there’s nothing special about the number ten. If we could start over (and why not?), base 12 would be a much better choice. For example, 1/3 in base 10 is “0.333…” and in base 12 it’s “0.4”; much nicer. More succinctly: 0.333…_{10} = 0.4_{12}

Because we work in base 10, if you tried to “build a tower to one” from below, you’d want to use the largest possible number each time. 0.9_{10} is the largest one-digit number, o.99_{10} is the largest two-digit number, 0.999_{10} is the largest three-digit number, etc. This is because “9_{10}” is the largest number in base 10.

In the exact same way, 0.8_{9} is the largest one-digit number in base 9, 0.88_{9} is the largest two-digit number, and so on. The same way that it works in base 10, in base 9: 1_{9} = 0.888…_{9} !

The easiest way to picture the number 1 as an infinite sum of parts is to picture 0.111…_{2} , “0.111…” in base 2.

If you cut take a stick and cut it in half, then cut one of those halves in half, then cut one of those quarters in half, and so on, the collected set of sticks would have the same length as the original stick. One half, 0.1_{2 }, plus 1 quarter, 0.11_{2 }, plus 1 eighth, 0.111_{2 }, add infinitum equals one. That is to say, 1_{2 }, = 0.111…_{2 }.

But things get tricky when you get to base 1. The largest value in a given base is always less than the base; 9 for base 10, 6 for base 7, 37 for base 38, 1 for base 2. So you’d expect that the largest number in base 1 is 0_{1 }. The problem is that the whole idea of a base system breaks down in “base 1”. In base ten, the number “abc.de_{10 }.” means “ax10^{2} + bx10^{1} + cx10^{0} + dx10^{-1} + ex10^{-2}” (where “a” through “e” are some digits, but who cares what they are). More generally, in base B we have abc.de_{B }= axB^{2} + bxB^{1} + cxB^{0} + dxB^{-1} + exB^{-2}.

But in base 1, abc.de_{1 }= ax1^{2} + bx1^{1} + cx1^{0} + dx1^{-1} + ex1^{-2} = a+b+c+d+e. That is to say, every digit has the same value. Rather than digits to the left being worth more, and digits to the right being worth less, in base 1 every position is the same as every other. So, base one is a number system where the position of the numbers don’t matter and *technically* the only number you get to work with is zero. Not useful.

If you’re gauche enough to allow the use of the number 1 in base 1, then you can count. But not fast.

In base 1, 1 = 10 = 0.000001 = 10000 = 0.01. Therefore, the infinitely repeating number 0.111…_{1} = ∞. That is, if you add up an infinite number string of 1’s, 1+1+1+1…, then naturally you get infinity.

In short: The “1 = 0.999… thing” is just a symptom of how the our number system is constructed, and has nothing in particular to do with 9’s or 10’s. The base 1 number system is kind of a mess and, outside of tallying, isn’t worth using. Base 1 is broken when we consider this particular problem, but that’s to be expected since it’s usually broken.

**Answer Gravy**: We can use the definition of the base system to show that 1 = 0.999…_{10} = 0.333…_{4} = 0.555…_{6} etc. For example, when we write the number 0.999… in base 10, what we explicitly mean is

The same idea is true in any base B, . Showing that this is equal to one is a matter of working this around until it looks like a geometric sum, , and using the fact that .

Notice that issues with base 1, B=1, crop up twice. First because you’re adding up nothing, 0=B-1, over and over. Second because when B=1. So don’t use base 1. There are better things to do.

The excellent pdf about constructing the real numbers was written by this guy.

Interesting, but if we consider decimal points in any base to really be convenient representations of fractions, then doesn’t the logic behind 1 = 0.999… apply to any repeating decimal? Taking your binary stick as an example, the sum of the fractions of sticks adds up to the whole stick, hence why we can say 1(base2) = 0.111…(base2). But the sum of the fractions should still add up to the same whole regardless of what base we use to express the fractions, shouldn’t it? Does that mean 1(base10) = 0.555…(base10)? And can that be extrapolated to any fraction? So 1(base10) = 0.888…(base10) or 1(base8) = 0.222…(base8)? In each case, adding further precision to the decimal brings us closer to one, so infinite precision is one regardless of the numbers? Am I not looking at things correctly here?

@Vincente Tellez

The problem with 0.555… is that each term is a tenth the size of the previous term, as opposed to half. It’s still a number (somewhere between 0.5 and 0.6), just not 1.

Quick proof:

x = 0.999…

→ 10x = 9.999…

→ 10x – x = (9.999…) – (0.999…)

→ 9x = 9

→ x = 1

→ 1 = 0.999…

That 1=0.999… was never surprising to me as apparently for the author of the article. It is very easy to see that there is no point between 1 and 0.999…, yet if the numbers were different, there would be points between them (there are infinitely many points between any two different real numbers). It follows that they can’t be different.

Well, 0.999… = 1 just as much as 0.333… = 1/3. The … means to take the limit of the sequence as the number of digits increases without end. Or as my analysis book states it, the lowest upper bound of the sequence.

As for base 1, you can add and multiply with it. Silly, very laborious, and therefore not worth doing, but it can be done.

First, do not use a decimal point.

| = 1

|| = 2

||| = 3

etc.

Now we’re ready to go.

|| + ||| = |||||

2 + 3 = 5

Multiply? Sure! It may well not show up properly here. You need a fixed-width font. Try copying a pasting it to an text editor if need be. Here’s 2 x 3:

|||

x||

—-

|||

|||

——

| + (| + |) + (| + |) + |

= | + || + || + |

= ||||||

With a little imagination you can even subtract! We need to add negative numbers to the mix. -1 would be represented by -|, with | + (-|) = 0, and 0 being the additive identity.

3 – 2 = 1

||| – || = ||| + (-|) + (-|) = | + [ | + (-|) ] + [ | + (-|) ] = | + 0 + 0 = |

2 – 3 = -1

|| – ||| = | + (-|) + | + (-|) + (-|) = 0 + 0 + (-|) = -|

I suppose you could even multiply with negative numbers, but the typing is painful! Division would be tough, and would be limited to calculation of a quotient plus a remainder. For 7/2 you would write |||||||, then count how many times you can remove || repeatedly until you have to stop. For 7/2 you would get 3 r 1, of course.

Well, this _is_ silly — and seriously labor intensive! It works, but it’s really just a silly way to write integers. (^_^)