What is This?

This page is a small Kaktovik arithmetics test and reference for me to augment my learning of Kaktovik numerals. On every reload, it generates a new arithmetic action, out of addition, subtraction, multiplication, and division (more to come!) On two Kaktovik numerals. The goal is to input the right result in Kaktovik numerals.

The keyboard below the problem is both clickable and keyboard-accessible via accesskey (in parentheses) (See the docs for exact modifiers to press, they differ between platforms.)

How to Count in Kaktovik?

So Kaktovik numerals are a base-20 (vigesimal) system, with digits denoting numbers from 0 to 19:

Kaktovik symbols and their decimal counterparts

Symbol	Decimal value	Name	My contraction
𝋀	0	kisitchisaġvik	kis
𝋁	1	atausiq	at
𝋂	2	malġuk	mal
𝋃	3	piŋasut	pin
𝋄	4	sisamat	sis
𝋅	5	tallimat	tal
𝋆	6	itchaksrat	itch
𝋇	7	tallimat malġuk	tallimal
𝋈	8	tallimat piŋasut	tallipin
𝋉	9	quliŋŋuġutaiḷaq	quligut
𝋊	10	qulit	qul
𝋋	11	qulit atausiq	quliat
𝋌	12	qulit malġuk	qulimal
𝋍	13	qulit piŋasut	qulipin
𝋎	14	akimiaġutaiḷaq	akigut
𝋏	15	akimiaq	aki
𝋐	16	akimiaq atausiq	akiat
𝋑	17	akimiaq malġuk	akimal
𝋒	18	akimiaq piŋasut	akipin
𝋓	19	iñuiññaġutaiḷaq	inugut
𝋁𝋀	20	iñuiññaq	inu
And so on…

Now, there also is a “sub-base” of 5: the digits are split into two parts: upper and lower. The upper part denotes multiples of 5. I’ll call them “ticks,“ for the lack of a better terminology. (This, technically, makes the system quinary-vigesimal, whatever that might mean.) The lower part denotes units of 1, “sticks”.

The system is simple: one stroke—one unit. So 𝋋 is one stroke / stick in units and two strokes / ticks in fives. So 1 + 2×5 = 11 And the highest digit—𝋓—is four units and three fives. 4 + 3×5 = 19.

See how visual the system is? This makes it a unique-ish numeric notation that maps well onto arithmetics. With addition, subtraction, and division being almost fully graphical computations. (Multiplication is still table-based or otherwise complicated.) Especially nice for calculations on paper. Less so—for computers, where you can just whip up a Lisp REPL and do

(expt 2 10000)
19950631168807583848837421626835850838234968318861924548520089498529438830221946631919961684036194597899331129423209124271556491349413781117593785932096323957855730046793794526765246551266059895520550086918193311542508608460618104685509074866089624888090489894838009253941633257850621568309473902556912388065225096643874441046759871626985453222868538161694315775629640762836880760732228535091641476183956381458969463899410840960536267821064621427333394036525565649530603142680234969400335934316651459297773279665775606172582031407994198179607378245683762280037302885487251900834464581454650557929601414833921615734588139257095379769119277800826957735674444123062018757836325502728323789270710373802866393031428133241401624195671690574061419654342324638801248856147305207431992259611796250130992860241708340807605932320161268492288496255841312844061536738951487114256315111089745514203313820202931640957596464756010405845841566072044962867016515061920631004186422275908670900574606417856951911456055068251250406007519842261898059237118054444788072906395242548339221982707404473162376760846613033778706039803413197133493654622700563169937455508241780972810983291314403571877524768509857276937926433221599399876886660808368837838027643282775172273657572744784112294389733810861607423253291974813120197604178281965697475898164531258434135959862784130128185406283476649088690521047580882615823961985770122407044330583075869039319604603404973156583208672105913300903752823415539745394397715257455290510212310947321610753474825740775273986348298498340756937955646638621874569499279016572103701364433135817214311791398222983845847334440270964182851005072927748364550578634501100852987812389473928699540834346158807043959118985815145779177143619698728131459483783202081474982171858011389071228250905826817436220577475921417653715687725614904582904992461028630081535583308130101987675856234343538955409175623400844887526162643568648833519463720377293240094456246923254350400678027273837755376406726898636241037491410966718557050759098100246789880178271925953381282421954028302759408448955014676668389697996886241636313376393903373455801407636741877711055384225739499110186468219696581651485130494222369947714763069155468217682876200362777257723781365331611196811280792669481887201298643660768551639860534602297871557517947385246369446923087894265948217008051120322365496288169035739121368338393591756418733850510970271613915439590991598154654417336311656936031122249937969999226781732358023111862644575299135758175008199839236284615249881088960232244362173771618086357015468484058622329792853875623486556440536962622018963571028812361567512543338303270029097668650568557157505516727518899194129711337690149916181315171544007728650573189557450920330185304847113818315407324053319038462084036421763703911550639789000742853672196280903477974533320468368795868580237952218629120080742819551317948157624448298518461509704888027274721574688131594750409732115080498190455803416826949787141316063210686391511681774304792596709376

For this next part I’ll pick up a piece of paper and do computations there. Do so too!

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

Take the two rightmost digits of the numbers to be added.
1. If the numbers can be drawn together into a valid digit, go to 4
2. 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.
3. Write the two resulting digits merged in the current digit place.
4. Move to next pair of digits, adding the overflow stick when necessary, and repeat 2-4.
5. 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:

If the subtrahend (right number) is larger than the minuend (left number,) remember that the result should be negated and swap these.
1. Take rightmost digits from both numbers.
2. If the right digit fully fits into the left one, go to 4.
3. 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.
4. Remove the right digit from the resulting left digit complex and write down the result in current digit place.
5. Move to next two digits, repeat 2-4
6. If there are remaining digits in the left number, but no digits in the right one—just transfer these digits into the result.
7. 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:

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

Halving

Not useful for Egyptian multiplication, but vital to Russian peasant multiplication. In case you want to use it instead of Egyptian 😉 And just because it seemed fun!

This is highly heuristic, but easy enough to remember:

Start from the leftmost digit of the number.
1. For every two ticks or sticks, write one tick / stick into the result respectively.
2. If there are some ticks or sticks remaining
   If there is only 𝋅 (one tick) left, add 𝋂 (two sticks) to the result and 𝋊 (two ticks) to the result of next digit (sic) halving.
   • If there’s 𝋆 left, add 𝋃 (three sticks) to the result.
   • If there’s 𝋈 left, add 𝋄 (four sticks) to the result.
   • If there’s 𝋁 left, add 𝋊 (two ticks) to the result of next digit halving and nothing to the current digit result.
3. Move to the next digit and half it.

Four special cases and otherwise fully visual computation. Not too bad?

Doubling

It’s easiest to just double ticks, then double sticks, then replace five sticks with one tick and replace four ticks with added stick in next position. That’s it. Again, purely graphical.

You can also learn a multiplication table from each of 19 digits to its doubled version. Which is still less than the per-component tables (12 + 16 + 9 = 37,) but much less fun than crossing out sticks.

Multiplication table for X × 2

𝋀	𝋁	𝋂	𝋃	𝋄	𝋅	𝋆	𝋇	𝋈	𝋉	𝋊	𝋋	𝋌	𝋍	𝋎	𝋏	𝋐	𝋑	𝋒	𝋓
𝋀	𝋂	𝋄	𝋆	𝋈	𝋊	𝋌	𝋎	𝋐	𝋒	𝋁𝋀	𝋁𝋂	𝋁𝋄	𝋁𝋆	𝋁𝋈	𝋁𝋊	𝋁𝋌	𝋁𝋎	𝋁𝋐	𝋁𝋒

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: 𝋁 𝋂𝋂 𝋂 𝋄𝋄 𝋄 𝋈𝋈 𝋈 𝋐𝋐 𝋐 𝋁𝋍𝋌 𝋁𝋌 𝋃𝋇𝋄 𝋃𝋄 𝋆𝋎𝋈 𝋆𝋈 𝋍𝋈𝋐 𝋌𝋐 𝋁𝋆𝋑𝋌

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.

Square root

The original paper by Bartley mentioned that Kaktovik numerals make it easy for students to calculate square root. I haven’t yet found the algorithm they used for that. But I’m hopeful!

Where to Next?

I hope this (not particularly) small page made you learn something about Kaktovik numerals. Thanks for getting this far! Lots of love 💙