I observed a strange anomaly in the sequence of bases of a number system.

For every $n$-base, $n \geq 2$, it holds that its number symbols are written with numerals which are all less than $n$. For example, a binary ($2$-ary) base has number symbols which consist only of $1$s and $0$s.

The anomaly manifests when we investigate $n = 1$. By the above pattern, its number symbols should consist only of $0$s. But if this were so, the only number we could express would be $0$. Hence, we have to break the pattern and allow $1$ to appear in our number symbols. We have to break another pattern, namely that the number symbols of a $n$-base consist precisely of $n$ different types of numerals, if we want $0$ to be representable in our system. That is, if we allow only $1$s in our number symbols, we cannot represent $0$.

For clarity, here is a sample definition of the value of number symbols, and an example from my imagined unary system. $$ (k_m k_{m-1} \dots k_1 k_0)_n = \sum_{i=0}^m n^i k_i $$ Then, the number symbols of the unary system are the same as that of the binary, with the difference that in the unary system, they denote a natural number equal to the number of $1$s which occur in them. For example, $(1101)_1$ is $3$.

I find it surprising that the elegant pattern described above completely breaks down at $n = 1$. Do we have analogous examples, or a deeper reason that this happens? Thank you for your input! :)

  • 1
    $\begingroup$ Technically you don't need the digit $0$, as the number $0$ can be written as an empty string of digits. That is, $0 = ()_1$ $\endgroup$ Commented Jul 9, 2023 at 12:56
  • 1
    $\begingroup$ @eyeballfrog Good idea, though my definition of valuation does not allow for that. It would also be hard to write empty strings on paper. :) Is this trick ever used in serious mathematics? $\endgroup$
    – God bless
    Commented Jul 9, 2023 at 13:00
  • 1
    $\begingroup$ It does sort of show up in computational complexity theory. There unary is used to make inputs exponentially longer, artificially lowering the complexity of an algorithm, which can be helpful in some proofs. In that context, the empty input is indeed used for $0$, though complexity theory is more concerned with behavior under very large inputs rather than small ones. $\endgroup$ Commented Jul 9, 2023 at 13:10
  • 3
    $\begingroup$ I don't understand your question. Base-$n$ system is only defined for $n\ge 2$. The "unary" system is not a Base-$1$ system, it is somewhat different. So no wonder the "pattern" breaks for $n=1$: we've already broken the pattern by defining it differently than for any other $n$'s. Had we not broken the pattern, all we could represent would be the number $0$. And all of this is already known to you. It is like breaking a chair and then asking "why is this chair broken?". $\endgroup$
    – user700480
    Commented Jul 9, 2023 at 13:35
  • $\begingroup$ @StinkingBishop You can word the issue this way, but my question remains: why is it the case that this nice property for number systems only holds for $n \geq 2$? $\endgroup$
    – God bless
    Commented Jul 9, 2023 at 13:46

1 Answer 1


(If we are happy only being able to represent natural numbers) the empty string can represent 0 and the only allowed digit can be 1.

In a way it will be more elegant as the number 1 will correspond to the "successor" operator in the Peano arithmetical sense.

But as Jean Marie states, this will not be a positional number system. Every "1" symbol will have the same value which it adds.


You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .