I have no clue how to make senary numbers work with screen readers, sorry. If you have any suggestions, or just wanna contact me, send an email to calculovolinguistics@gmail.com.
Balanced Senary, occasionally shortened to BalSen, is a positional notation number system that uses base six, and negative digits. It's similar but still distinct from decimal, and it's better in a few ways.
In this page, I will show you BalSen's interesting features and why I like it so much. As such, excluding the following tutorial sections and a few parts where I specify decimal numbers, this page uses BalSen. The entire neocities is in Balsen actually, but there's decimal help in parenthesis.
Skip to tutorial B if you don't want a new explanation of how number bases work, though you might be confused by the box analogy.
Balanced Senary is a method of writing numbers. To understand better its advantages, a recap of how our usual system (Natural Decimal) works will be helpful.
Imagine that you have a infinite array of boxes, each able to hold nine marbles.
0
0
0
0
0
0
0
0
0
...
You are given an amount of marbles and asked to count them. Sadly, you are a robot that can only place marbles in the array, take them out and read how many are in a box (stick with me).
The way you can count them is like this:
First, place a marble into box number 0.
...
0
0
0
0
0
0
0
0
1
...
0
0
0
0
0
0
0
0
2
...
0
0
0
0
0
0
0
0
3
If you can't place a marble into a box because it's full, take all of the marbles out (there should be ten) and place one into the box to its left.
...
0
0
0
0
0
0
0
0
9
...
0
0
0
0
0
0
0
0
10
...
0
0
0
0
0
0
0
1
0
That's it. All you need. Lemme show an example:
Say we do this with 215 marbles.
Following step 1 nine times, you end up with 0|0|9. We can't do step 1 again, so we do step 2 to get 0|1|0.
Nine more step ones get us to 0|1|9, then step 2 gets to 0|2|0.
Rinse and repeat until 0|9|9, which needs step 2 twice to go to 1|0|0. This has consumed 100 of the 215 marbles.
Repeat that whole song and dance to consume another 100 marbles, and the remaining fifteen are enough to get to 2|1|5.
The amount of marbles in each box forms the number in Decimal, also known as base-ten, since we turned groups of ten into one to get there, and a marble in a box is worth ten times the marbles on the box to its right.
Other bases use different group sizes: Dozenal uses dozens, Hexadecimal uses sixteen, Binary uses two, and our subject, Senary, uses six.
Now, what is the difference between a balanced base and a natural base?
A natural base limits itself to the natural numbers when writing. In terms of the box analogy, each box holds a natural (positive and whole) amount of marbles. Because of that, we must use boxes that can hold up to one less marble than the group size.
A balanced base... is a little weirder.
Let's say that you still make groups of ten, but now the boxes are only five marbles big. How can you make the number six?
Balanced bases solve that with negative marbles. If you take a positive marble and a negative marble at the same time, then the total amount of marbles hasn't changed, correct?
To write six in balanced decimal, you borrow four, to form a group of ten, and place the four negatives in the first box: 0|1|-4.
A few more examples of natural versus balanced decimal, to see if you understand it:
0
1
3
=
0
1
3
0
7
2
=
1
-3
2
0
8
6
=
1
-1
4
0
9
9
=
1
0
-1
Balanced senary is the result of combining the balance trick (three-sized boxes, negatives allowed) with base-six (six-sized groups.)
It is better than natural decimal in a few regards, but I personally just use it because it's lots of fun. (to me, a massive math nerd.)
Though before explaining where it beats decimal, I must get through a few issues: naming the numbers, writing them down and the 3/③ redundancy.
Saying negative one all the time is not going to cut it. There's less different competing standards for balanced names at least. By that I mean literally one person bothered getting that far and posting it online.
Neg /nεg/ is minus one, er /ɚ/ is minus two and san /sən/ is minus three, the first being a shortening of negative and the last two originating from Mandarin Chinese.
Big part of the naming scheme is borrowed from jan Misali's system for natural senary (though they call it "seximal"):
Numbers up to nine can use their standard names, just remember "nine" is 13;
20 (12) is called dozen, but for the others the -sy suffix is used: 30 (18) is called thirsy, ③0 (-18) is called sansy /sən'zi/, ②0 (-12) is called ersy /ɚ.zi/ and ①0 (-6) is called negsy /nεg.zi/.
1②0 can be called foursy, but I feel like it works better as nif ersy.
100 (36) is nif, 1000 (216) is tarumba (though it is not used very often, it's nicer to say dozen one nif than two tarumba one nif) and 1 0000 (1 296) is a unexian. The unexian series grows with prefixes every 101②, see more on the extended nomenclature page.
Naming Recap
BalSen Digits
BalSen Name
Decimal Value
③
san
-3
②
er
-2
①
neg
-1
0
zero
0
1
one
1
2
two
2
3 = 1③
three / six san
3
1②
four / six er
4
1①
five / six neg
5
10
six
6
11
seven / six one
7
12
eight / six two
8
13 = 2③
nine / six three / dozen san
9
2②
dozen er
10
2①
dozen neg
11
20
dozen
12
21
dozen one
13
22
dozen two
14
23 = 3③
dozen three / thirsy san
15
3②
thirsy er
16
3①
thirsy neg
17
30 = 1③0
thirsy / nif sansy
18
1③1
nif sansy one
19
1③2
nif sansy two
20
1③3 = 1②③
nif sansy three / nif ersy san
21
1②②
nif ersy er
22
1②①
nif ersy neg
23
1②0
nif ersy
24
1①0
nif negsy
30
100
nif
36
200
two nif
72
1000
six nif / tarumba
216
1 0000
unexian
1 296
10 0000
six unexian
7 776
100 0000
nif unexian
46 656
1012
biexian
1 679 616
1020
triexian
2 176 782 336
103②
unerexian
2.821×1012
101③2
unnegexian
3.656×1015
101②0
unnilexian
4.738×1018
101①②
ununexian
6.141×1021
101①2
unbiexian
7.959×1024
10100
untriexian
1.031×1028
You may notice that every number in the table above containing a 3 could be rewritten with ③ by adding 1 to the digit to the left. This is a purposeful redundancy, that makes the number system truly balanced.
This is a side effect of how we adapted the concept of a balanced base to senary. Originally, balanced bases' best properties were restricted to odd numbers, since they can have the same amount of positive and negative digits (base-n requires n digits, including zero. If n is even, there's an odd amount of digits left.).
To keep the patterns spotted in true balanced bases, BalSen uses the neighbor rule: any number should look like its closest neighbor in higher magnitudes.
For example: seventeen is 03①, because it is closer to zero (000), while nineteen is 1③1, because it is closer to thirty six (100). eighteen is right in the middle so both 30 and 1③0 are allowed.
To do this quickly, follow these rules:
3 always is used to the left of negative digits, while ③ always is used to the left of positive digits.
Before the ending of a number, it is interchangeable, though it is recommended to follow the number's overall sign. (nine is 13, negative nine is ①③)
Before a zero, skip ahead to the next digit over to repeat the test, until one of the two cases above happen. (one hundred and seven is 30①, one hundred and eight preferred to be 300, and one hundred and nine is 1③01.)
Now that you know how BalSen works, I will write the rest of the page with senary numbers.
The Advantages of Balanced Senary
Bases are surprisingly insignificant in the grand scheme of things, but there's a few advantages and disadvantages that come from their sizes. Plus, there's the effects of balancing!
As long as the rules in the previous block are followed, truncating a number should be the same as rounding it. That happens automatically in odd balanced bases, but odd bases can't even divide by two easily! In terms of division, the smallest base comparable to six is 23! Over double the size!
Another result is that magnitudes are much closer linked to size: numbers with n digits are all close to 10n-1 (between half and thrice it to be precise), unlike natural bases where numbers like ninety-nine are much closer to one hundred than ten.
The larger a base is, the worse its addition and multiplication tables get. For example, 2②'s table is 3①② numbers, and 20's table is 1②00 numbers! Well, less than half of those actually matter, but it's still quite sizeable!
Here's balanced senary's addition table, so you can see how small it is:
+
③
②
①
0
1
2
3
③
①0
①1
①2
③
②
①
0
②
①1
①2
③
②
①
0
1
①
①2
③
②
①
0
1
2
0
③
②
①
0
1
2
3
1
②
①
0
1
2
3
1②
2
①
0
1
2
3
1②
1①
3
0
1
2
3
1②
1①
10
As you can see, only 121 numbers. Not only that, this is both the addition and the subtraction table! In balanced bases, you can write negative numbers with regular digits, and don't need to directly subtract! You don't even need to borrow anymore, just pass the occasional ①.
However, I believe that the multiplication table is much more interesting...
×
③
②
①
0
1
2
3
③
13
10
3
0
③
①0
①③
②
10
1②
2
0
②
①2
①0
①
3
2
1
0
①
②
③
0
0
0
0
0
0
0
0
1
③
②
①
0
1
2
3
2
①0
①2
②
0
2
1②
10
3
①③
①0
③
0
3
10
13
Now, let's notice a couple of things.
The table is symmetrical in relation to its left to right diagonal, cutting the amount of results needed to memorize by half. This happens in natural tables too.
You can get rid of 0 and 1's rows, since multiplying anything by zero gives zero and multiplying anything by one gets itself.
The table is, in a way, also symmetrical in relation to the zero axii, because, for example, if you know 2×3=10, you can deduce ②×3=①0, 2×③=①0 and ②×③=10.
Using all these strategies, the table becomes...
×
2
3
2
1②
10
3
-
13
A grand total of three results. Gone are the days of memorizing dozens upon dozens of results! It's so good I even get a little worried about it undershooting mental capacity!
This is probably where senary and balancing's weaknesses compound the most, but it isn't too bad.
Numbers in any natural base n grow in length following 1 + logn (rounded down) of the number. That results in senary numbers becoming longer than decimal by in average 2②.1 per nif (around twenty-eight percent).
Meanwhile, numbers in balanced bases grow following 1 + logn (rounded down) of double the number. Here this results into an increase that slowly becomes less relevant, but still causes trouble.
Thankfully, we have a card up our sleeve: Balanced niftimal.
Balanced Niftimal from Balsen
③
②
①
0
1
2
3
③0
-
&
J
K
L
②0
L
M
N
O
P
Q
R
①0
R
S
T
U
V
W
X
00
X
Y
Z
0
1
2
3
10
3
4
5
6
7
8
9
20
9
A
B
C
D
E
F
30
F
G
H
I
-
This is directly inspired by this solution to the problem in natural senary, and it's surprisingly easy to convert between them. Simply go from right to left: If you find a letter between J and Z, add one to the digit to its left. (since natural senary has, for example, J=1③1 while balanced has just ③1) If you find an I, do a test similar to the test we do with 3 in balanced senary: if it has a negative (& and J through Z)to its right, keep it. If it has a positive (1 through 9 and A through I) to its right, change it to & and add one to the digit to its left. If it has a zero to its right you skip it and if it hits the end of the number it is interchangeable. For example, SHACK would become 1SHADK, and BAIL would become BBJL.
Now, while the ampersand looks a little off together with the other letters, there is precedent of it being in the alphabet. Plus, most langs that use the latin alphabet have some extra letters, such as Spanish ñ. Heck, even the þorn enþusiasts could have some fun! Just make sure you keep it to the ③0 slot.
Six is known as a superior highly composite number, which basically means it has many factors. Having many factors is so surprisingly useful we have two headers dedicated to that.
One thing that is very obvious in natural decimal is that two and five are easy to deal with, and three, nine and eleven aren't too hard. Meanwhile, seven is notoriously difficult, for reasons you will get in a second.
A base always deals best with its own divisors: decimal is good for two and five, dozenal for two, three and four, hexadecimal for two and four, and our little boy senary is good with twos and threes. This is visible in the divisibility tests, being as simple as possible: a number is divisible by two (even) if it ends in 2, 0 or ② and divisible by three (threeven) if it ends in 3, 0 or ③. This pattern extends to any number of the form 2m×3n, checking if the last m digits divide by 2m and if the last n digits divide by 3n.
"That just sounds redundant", I hear you say, person who just noticed ten has as many divisors as six and that twelve has even more. Well, those are not the only numbers a base deals with well. There's also its predecessor. You may know that if you add all the digits of a number and the result is divisible by nine, the original is also divisible by nine. Here, a similar trick exists, but with five. For example: 1②②3 → 1+②+②+3 = 0. (Given enough tests, any number divisible by 1① decays to 0.)
"Well, you're just swapping fifths for thirds", you say next. However, there's a final notable number: the one immediately after the base. In decimal, you can spot multiples of eleven by their notable repetition: 11; 22; 33; 44, etc. A similar pattern exists in senary, as the multiples of seven: 11, 22, 1③3... To check whether a number is divisible by seven, flip every other digit and do five's test. Example: 1 ①②①① → 11②1① → 1+1+②+1+① = 0. If that's too confusing, you can break the numbers into two digit chunks instead: 1 ①②①① → 01+①②+①① = ②② (obviously divisible by 11). You have to agree seven is more important than eleven.
While dozenal seems good thanks to its extra factor, its neighbors 2① and 21 aren't as useful as 1① and 11, which senary is good at but dozenal ignores. Decimal is better in that regard, catching 3 through its neighbor 13, but still prefers 2① to 11.
A thing people really love to compare is the reciprocals of numbers in their bases. Here's natural senary, when compared to decimal and dozenal:
Senary
Decimal
Dozenal
1/2
0,3
0.5
0;6
1/3
0,2
0.3
0;4
1/1②
0,13
0.25
0;3
1/1①
0,1
0.2
0;2497
1/10
0,1
0.16
0;2
1/11
0,05
0.142857
0;186A35
1/12
0,043
0.125
0;16
1/13
0,04
0.1
0;14
1/2②
0,03
0.1
0;12497
1/2①
0,0313452421
0.09
0;1
1/20
0,03
0.083
0;1
Remember: the worst length one of those can be is one less than the denominator, since, when you divide, the remainder must be between zero and the denominator and repeating a remainder closes the loop.
Base ten does pretty well, until writing sevenths as bad as a base could possibly write them. Dozenal hits the spot earlier, on fifths, while not even fixing the sevenths.
Meanwhile, senary's mastery proves itself yet again, by taking until dozen neg to have a worst possible period.
But remember: that table used natural senary. Balancing it creates a very notable pattern:
Natural
Balanced
1/2
0,3
0,3
1,③
1/3
0,2
0,2
1/1②
0,13
0,13
0,2③
1/1①
0,1
0,1
1/10
0,1
0,1
1/11
0,05
0,1①
1/12
0,043
0,1②3
0,1①③
1/13
0,04
0,1②
1/2②
0,03
0,1③
1/2①
0,0313452421
0,1③2②①①3②21
1/20
0,03
0,03
0,1③
Look closer at some of the periods... For example, 0,1③2②①①3②21 breaks down into 1③2②① and ①3②21, which are negative versions of eachother! This happens due to a long division algorithm that flows better in balanced bases. It is almost the same as the usual, but you can have negative remainders and digits in the quotient, as long as the absolute value of the remainder is less than half the divisor. Allowing negative remainders turns the list of usable remainders from [1,2,3, ..., 12, 13, 2②] to [①1, ①2, ③, ..., 3, 1②, 1①]. Logically, once we hit a negative version of a remainder we previously hit, we have to repeat the results, but with a flipped sign.
If we compress these with a special notation (I use double overlines which are clunky but get the job done), we have:
Natural
Balanced
1/11
0,05
0,1
1/2①
0,0313452421
0,1③2②①
With that, BalSen only hits decimal one seventh levels of bad with one over dozen one's representation.
Closing Thoughts
If this page has convinced you to use BalSen, great! If it hasn't it's fine too, I accept making the entire world change bases would be difficult. I mean, the Dozenal Societies have been trying for the last many years and many days! As Marge puts it best...
I will update this page when I come up with a BalSenic system of measurement and some translations of the nomenclature. While that doesn't happen, play with the little NatDec to BalSen translator below!
