Toolforger has one thing right: Binary computers are the most efficient computing devices possible. Period. Ternary has no technological advantage, whatsoever.
However, I'm going to give a suggestion of how you can offset the disadvantage of ternary computing, to allow your society to actually use ternary computers instead of binary ones:
Your society has evolved to use a balanced numeral system.
Balanced numeral systems don't just use positive digits like we do, they use an equal number of negative and positive digits. As such, balanced ternary uses three digits for -1, 0, and 1 instead of the unbalanced 0, 1, and 2. This has several beneficial consequences:
Balanced numeral systems have symmetries that unbalanced systems lack. Not only can you exploit commutativity when doing calculations (you know what 2+3 is, so you know what 3+2 is), but also symmetries based on sign: -3-2 = -(3+2), -3*2 = 3*-2, -3*-2 = 3*2, and 3*-2 = -(3*2).
You have more computations with trivial outcome: x+(-x) = 0 and -1*x = -x.
The effect is, that you have much less to learn when learning balanced numeral systems. For instance, unbalanced decimal requires you to learn 81 data points by heart to perform all the four basic computations, whereas balanced nonal (9 digits from -4 to 4) requires only 31 data points, of which only 6 are for multiplication. The right-most column uses `-4 = d, -3 = c, -2 = b, and -1 = a as negative digits:
2*2 = 0*9 +4 = 4
2*3 = 1*9 -3 = 1c
2*4 = 1*9 -1 = 1a
3*3 = 1*9 +0 = 10
3*4 = 1*9 +3 = 13
4*4 = 2*9 -2 = 2b
The entire rest is either trivial or follows from symmetries. That's all the multiplication table your school kids need to learn!
Because you can get both positive and negative carries, you get much less and smaller carries in long additions. They simply tend to cancel each other out.
Because you have negative digits as well as positive ones, negative numbers are just an integral part of the system. In decimal, you have to decide which number is greater when doing a subtraction, then subtract the smaller number from the larger one, then reattach a sign to the result based on which of the two numbers was greater. In balanced systems you don't care which number is greater, you just do the subtraction. Then you look at the result and see whether it's positive or negative...
As a matter of fact, I once learned to use balanced nonal just for fun, and in general, it's indeed much easier to use than decimal.
My point is: To anyone who has been brought up calculating in a balanced numeral system, an unbalanced system would just feel so unimaginable awkward and cumbersome that they will basically think that ternary is the smallest base you can use. Because binary lacks the negative digits, how are you supposed to compute with that? What do you do when you subtract 5 from 2? You absolutely need a -1 for that!
As such, a society of people with a balanced numeral system background may conceivably settle on balanced ternary computers instead of binary ones. And once a chunk of nine balanced ternary digits has been generally accepted as the smallest unit of information exchange, no one will want to use 15 bits (what an awkward number!) to transmit the same amount of information in a binary fashion, with all the losses that would imply.
The result is basically a lock-in effect to balanced ternary that would keep people from using binary hardware.
Aside: Unbalanced decimal vs. balanced nonal
Here is a more detailed comparison between decimal and balanced nonal. I'm using a, b, c, d
as the negative digits -1, -2, -3, -4
here, respectively:
Negation
Here the learing effort for decimal is zero. For balanced nonal, you have to learn the following table with nine entries:
| d c b a 0 1 2 3 4
--------+------------------
inverse | 4 3 2 1 0 a b c d
Addition
Decimal has the following addition table, the right table show the 45 entries that need to be learned:
+ | 0 1 2 3 4 5 6 7 8 9 + | 0 1 2 3 4 5 6 7 8 9
--+----------------------------- --+-----------------------------
0 | 0 1 2 3 4 5 6 7 8 9 0 |
1 | 1 2 3 4 5 6 7 8 9 10 1 | 2
2 | 2 3 4 5 6 7 8 9 10 11 2 | 3 4
3 | 3 4 5 6 7 8 9 10 11 12 3 | 4 5 6
4 | 4 5 6 7 8 9 10 11 12 13 4 | 5 6 7 8
5 | 5 6 7 8 9 10 11 12 13 14 5 | 6 7 8 9 10
6 | 6 7 8 9 10 11 12 13 14 15 6 | 7 8 9 10 11 12
7 | 7 8 9 10 11 12 13 14 15 16 7 | 8 9 10 11 12 13 14
8 | 8 9 10 11 12 13 14 15 16 17 8 | 9 10 11 12 13 14 15 16
9 | 9 10 11 12 13 14 15 16 17 18 9 | 10 11 12 13 14 15 16 17 18
The same table for balanced nonal only has 16 entries that need to be learned:
+ | d c b a 0 1 2 3 4 + | d c b a 0 1 2 3 4
--+-------------------------- --+--------------------------
d |a1 a2 a3 a4 d c b a 0 d |
c |a2 a3 a4 d c b a 0 1 c |
b |a3 a4 d c b a 0 1 2 b |
a |a4 d c b a 0 1 2 3 a |
0 | d c b a 0 1 2 3 4 0 |
1 | c b a 0 1 2 3 4 1d 1 | 2
2 | b a 0 1 2 3 4 1d 1c 2 | 1 3 4
3 | a 0 1 2 3 4 1d 1c 1b 3 | 1 2 4 1d 1c
4 | 0 1 2 3 4 1d 1c 1b 1a 4 | 1 2 3 1d 1c 1b 1a
Note the missing diagonal of zeros (a number plus its inverse is zero), and the missing upper left half (the sum of two numbers is the inverse of the sum of the inverse numbers).
For instance, to calculate b + d
, you can easily derive the result as b + d = inv(2 + 4) = inv(1c) = a3
.
Multiplication
In decimal, you have to perform quite a bit of tough learning:
* | 0 1 2 3 4 5 6 7 8 9 * | 0 1 2 3 4 5 6 7 8 9
--+----------------------------- --+-----------------------------
0 | 0 0 0 0 0 0 0 0 0 0 0 |
1 | 0 1 2 3 4 5 6 7 8 9 1 |
2 | 0 2 4 6 8 10 12 14 16 18 2 | 4
3 | 0 3 6 9 12 15 18 21 24 27 3 | 6 9
4 | 0 4 8 12 16 20 24 28 32 36 4 | 8 12 16
5 | 0 5 10 15 20 25 30 35 40 45 5 | 10 15 20 25
6 | 0 6 12 18 24 30 36 42 48 54 6 | 12 18 24 30 36
7 | 0 7 14 21 28 35 42 49 56 63 7 | 14 21 28 35 42 49
8 | 0 8 16 24 32 40 48 56 64 72 8 | 16 24 32 40 48 56 64
9 | 0 9 18 27 36 45 54 63 72 81 9 | 18 27 36 45 54 63 72 81
But in balanced nonal, the table on the right is reduced heavily: The three quadrants on the lower left, the upper right and the upper left all follow from the lower right one via symmetry.
* | d c b a 0 1 2 3 4 * | d c b a 0 1 2 3 4
--+-------------------------- --+--------------------------
d |2b 13 1a 4 0 d a1 ac b2 d |
c |13 10 1c 3 0 c a3 a0 ac c |
b |1a 1c 4 2 0 b d a3 a1 b |
a | 4 3 2 1 0 a b c d a |
0 | 0 0 0 0 0 0 0 0 0 0 |
1 | d c b a 0 1 2 3 4 1 |
2 |a1 a3 d b 0 2 4 1c 1a 2 | 4
3 |ac a0 a3 c 0 3 1c 10 13 3 | 1c 10
4 |b2 ac a1 d 0 4 1a 13 2b 4 | 1a 13 2b
For instance, to calculate c*d
, you can just do c*d = 3*4 = 13
. Or for 2*b
, you derive 2*b = inv(2*2) = inv(4) = d
. It's really a piece of cake, once you are used to it.
Taking this all together, you need to learn