Kaktovik Numerals Practice

Addition #

Okay, simple things typical to most positional numeric systems first: Adding two big things “overflows” (don’t beat me up on terminology, I’m not a math kid!) into the next position or tick. So adding 𝋂 (2) and 𝋄 (4) results in 𝋆 (6, one stick plus one tick.) Same as 2 + 9 = 10 + 1, but in 5-based system and graphically. So far so good.

Then, it can also get proper positional. We can not only overflow into ticks, we can overflow into positions. So adding 𝋂 (2) and 𝋓 (19) results in 𝋁𝋁 (21, one in twenties and one.) So it’s much like in decimal: add more than the current position can sustain, and you get +1 in the next position and some remainder.

So yeah, overflow in ticks is removal of one 𝋏, removal of one tick, and addition of 𝋁 stick to the next position. Overflow in sticks is removal of one 𝋄, removal of one stick, and one more 𝋅 tick to the result.

The full algorithm is

1. Take the two rightmost digits of the numbers to be added.
2. If the numbers can be drawn together into a valid digit, go to 4
3. If not, we have an overflow:
   1. If the overflow is in sticks / ones, remove five sticks and add one tick.
   2. If the overflow is (now) in ticks, remove four ticks and add one stick to next position.
4. Write the two resulting digits merged in the current digit place.
5. Move to next pair of digits, adding the overflow stick when necessary, and repeat 2-4.
6. If ran out of digits in one number, insert digits from another (longer) one, adding the overflow stick and handling respective overflow when necessary.

The procedure is the same as with decimal addition numerically, but it’s also augmented graphically. Here’s transcript of my thinking for 𝋁𝋁𝋑 + 𝋁𝋂𝋏:

So okay, three vigesimal places.
Starting with the rightmost, like in school math.
𝋑 + 𝋏 is an obvious overflow.
So we remove one Z-like glyph;
remove a tick from another one (𝋊;)
add the sticks unchanged (because there are no sticks in 𝋏, phew;)
and remember one stick for the future.
So 𝋌 and an overflow stick.
Now, to 𝋁 + 𝋂.
First, add the previous step stick: 𝋂 + 𝋂 now.
Then just glue these together: 𝋄.
The last pair (𝋁 and 𝋁) is easy too: just glue them into 𝋂.
Got 𝋂𝋄𝋌!

Purely graphical math. Just so you know: I added 437 and 455. I might’ve gone with a more complicated setup, bigger numbers, and more overflows. Sure. But that’s what this page generated for me, and I’m okay with the amount of challenge. Refresh / re-generate and try some addition yourself!

Subtraction #

Subtraction is removing sticks and ticks. Subtraction is nasty, because there are negative numbers if we subtract a bigger thing from smaller thing.

Let’s try 𝋃𝋈 - 𝋈𝋈. Obviously, the right one is bigger—there are more sticks. So the result in negative. But okay, we can add a minus and invert the relation: -(𝋈𝋈 - 𝋃𝋈) Now it’s possible to just remove sticks:

Starting with 𝋈 - 𝋈, getting 𝋀 (zero.)
Then 𝋈 - 𝋃, removing the duplicate part and getting 𝋅.
The result is simply 𝋅𝋀… but with a minus added from inverted relation!

Okay, more complicated example to demonstrate the heuristics: 𝋌𝋇 - 𝋇𝋉.

This is problematic: we have a subtrahend larger than minuend.
Elementary school technique: remove one stick from the upper position (𝋋 now)
and subtract from 𝋇 + 𝋓 + 𝋁 (initial number + 20.)
So it’s removal of 𝋉 from 𝋓, resulting in 𝋊.
Plus 𝋇 and 𝋁.
So 𝋒 in the ones position.
Now to 𝋋 - 𝋇.
Uh oh, another underflow.
This time, borrowing from the ticks: 𝋋 turns into 𝋆, but gets 𝋄 and 𝋁.
Can subtract 𝋇 from it now: (𝋆 + 𝋄 + 𝋁) - 𝋇 = 𝋄 + ((𝋆 + 𝋁) - 𝋇) = 𝋄.
Yeah, I just removed sticks and ticks in places that had them.
So 𝋄𝋒.

So underflow is when we remove either one tick—if underflow is merely in sticks. Or one stick from next position—if it’s in ticks. And then use that as full value in the current context plus one (adding 𝋓 + 𝋁 for positions, and 𝋄 + 𝋁 for sticks.) The full algorithm then is:

1. If the subtrahend (right number) is larger than the minuend (left number,) remember that the result should be negated and swap these.
2. Take rightmost digits from both numbers.
3. If the right digit fully fits into the left one, go to 4.
4. If there’s not enough of either sticks or ticks:
   1. If there are not enough sticks in left digit, remove one tick from it and add five sticks.
   2. If there are not enough ticks, take one stick from the next position and add four ticks.
5. Remove the right digit from the resulting left digit complex and write down the result in current digit place.
6. Move to next two digits, repeat 2-4
7. If there are remaining digits in the left number, but no digits in the right one—just transfer these digits into the result.
8. Apply the negation to the result if numbers were swapped at the start of the algorithm.

I mean, it’s all the same as elementary school, but without non-obvious Arabic numerals and decimal places.

First, inverting the relation: -(𝋃𝋃 - 𝋂𝋋).
Now 𝋃 - 𝋋.
𝋃 is less, so take one stick from the next position (𝋃 -> 𝋂.)
Now we have (𝋓 + 𝋁 + 𝋃) - 𝋋.
So remove two ticks from 𝋓 and one 𝋁.
Still, we have 𝋉 and 𝋃, which is a lot.
Using the overflow rule from addition section (-W, -l, +tick,) getting 𝋌.
What’s left is 𝋂 - 𝋂.
So 𝋀.
𝋀𝋌, or just 𝋌.
Oh, wait, there was a minus sign.
-𝋌!

Division #

I haven’t found more complex division examples on either Wikipedia, Artifexian’s video, nor even Bartley’s original writing. No one seems to have done division in public.

But, actually, it’s quite similar to subtraction, where we “borrow” sticks from the upper position to the lower one. And from ticks to sticks.

Operations are still quite graphical, and often as easy as removing ticks and sticks from numbers:

Notice the rotated 𝋃𝋁 in fives places. So we essentially get 𝋃𝋁 * 5, thus a tick instead of stick in result.

But, for more complex examples, I found that adding more sticks and ticks from remainders up to absurdly long zigzags keeps the system graphical. Without the need to use numerics at all.

𝋎𝋈 / 𝋍.
First, 𝋍 is obviously contained in 𝋎.
Just remove it once, to the result of 𝋁 in twenties position and remainder 𝋁.
Then, dividing 𝋈 by 𝋍.
𝋍 is larger than 𝋈.
Are we stuck?
No!
We take the remainder 𝋁 from the previous step and convert it 𝋁𝋀 -> 𝋅 + 𝋏.
So we have 𝋒 + 𝋊.
Which divides once, to a 𝋏 remainder.
Which divides too!
We take a tick and turn it into 𝋄 + 𝋁.
So we have 𝋎 + 𝋁.
Remove 𝋍 from there (second removal now) and get remainder of 𝋂.
With the result 𝋁𝋂 and remainder of 𝋂.

While this is not as pretty as the Wikipedia example, it is still pretty easy. Just downgrade some fives and twenties to their alternatives. Elementary school again, just visuals only! The only time I had to count things was to count sticks converted from ticks. And to count ticks converted from twenties. Which is easy enough to do visually once I’m used to this. The algorithm:

1. Take as many leftmost digits from the dividend as there are digits in the divisor.
2. If the divisor fits into these digits, go to 3
   1. If it doesn’t fit or there are too many remaining sticks,
   2. Downgrade one remainder from the previous position (if any) into four ticks.
   3. Downgrade one tick into five sticks.
   4. Repeat however many times necessary to get as many divisors fitting into this as possible.
   5. This is ultimately a riddle where you need to balance out sticks and ticks for maximum output. Enjoy!
3. Remove the divisor from the resulting digits N times, and write N into the resulting digits place.
4. If there were not entries for divisor even with downgraded remainders, write 𝋀.
5. Remember the remainder from the division in the current position.
6. Shift one position right in the dividend and repeat 2-5.
7. If there are less digits in the current dividend even with downgraded remainders, stop and write them in as a remainder.

Multiplication #

Wikipedia lists these multiplication tables for long multiplication, one per tick / stick pairing.

Which means that, for every pair of digits in multiplicands, there are maximum 6 sub-multiplications. For 3-digit long numbers, this easily goes up to 3 (digits) * 3 (other digits) * 6 = 36 sub-multiplications, disregarding (a lot of) resulting additions. Which is too much, and it feels like it can be improved.

There are many multiplication algorithms, with their tradeoffs and complexities. Here’s the ones I checked:

Long multiplication

Too long, suboptimal

Grid and lattice multiplication

These require having per-digit multiplication results, which, in case of base-20 Kaktovik amounts to 400 variations. Too much to make the method easy.

Intersection-based multiplication

Base-20 numbers require too many lines, and this method does not scale beyond four digits.

Russian peasant multiplication

Actually, why not? Halving is (almost) as simple in Kaktovik as removing every second stick / tick, while doubling is… slightly more complicated than that.

Egyptian multiplication

Even better—it only requires powers of two and doubling!

Other methods

Too much scary math, didn’t read

So, if we take Egyptian multiplication, we get log2(min(N,M)) multiplications for N × M multiplication. If we get long multiplication, we get log20(N)×log20(M)×6. These two might be comparable for small numbers, but grow apart on big ones.

So (probably) the most optimal Kaktovik multiplication algorithm is Egyptian multiplication. Refer to Wikipedia for the description. But, before doing Egyptian multiplication… halving and doubling!

Egyptian multiplication #

Now that doubling is in place, we only need a table of powers of two.

Powers of two in Kaktovik numerals

1	2	4	8	16	32	64	128	256	512	1024	2048	4096
𝋁	𝋂	𝋄	𝋈	𝋐	𝋁𝋌	𝋃𝋄	𝋆𝋈	𝋌𝋐	𝋁𝋅𝋌	𝋂𝋋𝋄	𝋅𝋂𝋈	𝋊𝋄𝋐

So we just take that and write out the table:

Example Egyptian multiplication of 𝋂𝋂 × 𝋁𝋄𝋉 = 𝋂𝋋𝋆𝋒

Power of two	Multiplier
𝋁	𝋂𝋂
𝋂	𝋄𝋄
𝋄	𝋈𝋈
𝋈	𝋐𝋐
𝋐	𝋁𝋍𝋌
𝋁𝋌	𝋃𝋇𝋄
𝋃𝋄	𝋆𝋎𝋈
𝋆𝋈	𝋍𝋈𝋐
𝋌𝋐	𝋁𝋆𝋑𝋌

With a total result of 𝋂𝋋𝋆𝋒. I have to admit, my first attempt to compute it was a failure. There was too much stuff for my stupid head. But I re-checked the computation in DevTools and decided I can do that too. Someday.