Visualizing Math with a Mental Slide Rule

Slide rules are really neat.

They give you a great intuitive understanding of mathematics. If you never used them before, they're easy enough. Here's a primer. If you haven't noticed, you can perform addition and subtraction using two ordinary rulers. There's obviously nothing magical here: you just mete out two distances, stacking them end to end, then measure their sum.

Slide rules work the same way, only with multiplication. This is made possible because slide rules place numbers on a logarithmic scale. An ordinary ruler just uses a linear scale. Slide rules work on the principle that `log(a*b) = log(a) + log(b)`.

Slide rules aren't normally used for mental math. This is because the markers on a slide rule indicate linear increments. Line spacing always changes, so unless you have a photographic memory, it is very difficult to visualize the addition of two distances.

If line spacing were constant though, we could multiply just by visualizing the slide rule.

It is possible to create a slide rule where line spacing is constant, but our lines could no longer represent linear increments. They would instead represent logarithmic increments. Every increment would represent a multiplication by some constant number.

Let's try to design this sort of slide rule. There are many values we could assign to its increments, but there are constraints we should consider. The scale must approximate the form `a^(1//n), a^(2//n), … a^(n//n)`. This is necessary to keep line spacing constant. Here, `a` is the base of our log scale. For us humans, it makes sense to set `a = 10`, since anything else will reduce the usability of our slide rule. If `a != 10`, our slide rule would not repeat once at every power of 10 and we'd likely have to convert number bases before calculations.

With these constraints in mind, we can browse from a pool of candidate log scales. Any viable log scale is of the form `10^(1//n), 10^(2//n), … 10^(n//n)`, where `n` is the number of increments on the scale. `n` is also the number of increments we'll need to memorize, so n should be small enough to remember but large enough to offer precision.

When school children memorize their multiplication tables, they generally memorize no more than 32 combinations, so we should be able to start simple, with `n<32`. Unlike the school children, though, every number we memorize goes further. Multiplication tables have a space complexity of `O(N^2)`, where `N` is the number of digits that can be multiplied. That means if we want to add just one extra number to our multiplication table, the number of combinations we have to memorize increases exponentially. Not only that, but the multiplication table only works well for multiplication. On the other hand, our slide rule only has a space complexity of `O(N)`. That means if we want to add one extra number to our ruler, we only have to remember one extra value. And as we will see, memorizing that value will allow us to do way more than multiplication.

It turns out `n = 10` is a rather good start, and if you want to learn more you can set n to some other multiple of 10.

Quite a few increments on this scale are conveniently close to whole numbers, those being 2, 4, 5, and 8. This probably has to do with the fact 10 is divisible by 2 and 5, but this is just a guess. Other numbers resemble rational fractions of 10, those being 1.25 and 2.5. There are 3 increments on this scale that correspond to neither whole numbers nor rational fractions, but we find these numbers are very close to `pi` and its multiples, ¹/₂`pi` and `2 pi`. It's fortunate that multiplication by `pi` is so common that most normal slide rules already come with a special notch for `pi`. Using `n = 10` has an added benefit: it leverages our existing knowledge of addition in base 10.

By visualizing the slide rule, we can divide and multiply just as easily as we add and subtract.

Because there are 10 numbers on our scale, our answers will be accurate to within ~10% the actual answer, assuming we round correctly. We can achieve greater accuracy by memorizing additional numbers.

We note that multiplication will be just as easy as single digit addition, but in fact it may be even easier. This is because there are additional mneumonics that help us visualize the scale. We will go through some mneumonics now.

The scale repeats at every power of 10, just as with arabic numerals, so we can visualize the scale as a sort of clock. Just like a clock, the numbers "roll over" if they go above or below the limits of the scale - 2 hours past 11:00 is 1:00.

The clock is divided into two halves. The halves are marked by two values. The first value is 1, which is multiplicative unity. The second is `sqrt(10)`, which is close to `pi`. There are four "steps" within each half. There are a total of 10 steps. The halves have a symmetry about them, so that the values on one half bear the same mantissa as the inverse of values on the other half. On the left half, we have `4`, `5`, `2 pi`, and `8`. On the right half, we have the mantissae of ¹/₄, ¹/₅ (or 2), ¹/₂`pi` (very close to `pi`/₂), and ¹/₈.

If we want to multiply two numbers, we count distance clockwise from the first number. The distance is determined by the second number - how far away that second number is from 1 (that is, the start of the scale)

If we want to divide two numbers, we do the same thing, only counter-clockwise.

To divide by large mantissae, it's often easier to multiply by the inverse of the number. Finding the inverse is easy - it's just the value on the opposite side of the clock. Let's divide 1.58 by 8. ¹/₈ is the first step on the clock, so the answer is one step clockwise from ¹/₂`pi`. The mantissa is 2. The answer is near 0.2. The actual answer is 0.19625.

What do we do if a number is between steps?

There's a few things we can do in that case. We can of course memorize additional numbers on the scale, but memory only takes us so far. Oftentimes, the best solution is interpolation - we estimate where the number lies between steps, then tack that on to an approximation that uses one of the two nearest values. If an answer is between steps, we interpolate between the two nearest values.

A more precise solution is to find the correction. Finding the correction in the log scale is just the same as finding the correction in arabic numerals - take the difference between the number and the approximation, multiply it seperately, then tack it on to the rest of your answer. You should be able to get an accurate number much faster than you would by multiplying with arabic numerals, though often you'll find the first order approximations are good enough.

This all sounds like stuff we can solve with other mental math. Oftentimes, I still find it easier to calculate in more traditional ways, particularly when dealing with simple whole numbers. However, the method does help us to make intuitive sense of the calculations. It also helps us focus on what's most important when calculating problems in the wild: first get the order of magnitude right, then get a good approximation for significant figures. Only then do we refine as needed. In lots of everyday problems, the order of magnitude will just "feel" right, so only the mantissa needs to be considered.

There are other things we can do with this visualization, too.

This brings us to our next point:

Visualizing the slide rule is very similar to memorizing the `log_10` table

Both are equally valid strategies. The difference lies with the part of the brain your using. If I memorized the `log_10` table and was asked to multiply two numbers, I'd map the two numbers to their `log_10` values, add the `log_10` values together, then map the sum back to get the answer. With the `log_10` table, I'm using rote memorization along with existing skillsets in addition. If I memorized the slide rule, I'd find the two numbers on the slide rule, visualize the addition, and estimate the order of magnitude. There's still rote memorization to a certain extent, but now I'm also using more spatial reasoning, intuition, and visual memory.

The good news is this: if you visualize the slide rule, the `log_10` values come easy and you can still fall back on using the `log_10` table if you find it useful. I find using the `log_10` table useful for calculating the powers and roots of large numbers.

We start to notice our answers become less accurate at higher powers. This is because the minor inaccuracies we started out with are amplified by repeated multiplication. This is a concern common to all slide rules.

Okay, we've shown what this can do. Now we want greater resolution. There are a number of integers missing on the scale.

If we find the answers to the questions above, we will immediately know `log_10` of ¹/₉, ¹/₇, ¹/₃, and ¹/₆ - we need only look at the opposite side of the clock!

It's particularly useful knowing positions for ¹/₉. We know ¹/₉ `= 1.111…`, so 1/2 step from any whole number is approximately that number repeated. Let's look at the whole numbers.

The actual numbers will be given shortly, but the above explanation is a useful mneumonic for memorizing the precise values of half steps. Once you memorize the precise values you can improve your accuracy to 6%.

You know what? Knowing the position for ¹/₉ is so useful, why don't we take it further? If we memorize all the quarter steps from 1 to 1.58, the values for all the other powers of two will fall into place. Once we memorize all the quarter steps, our accuracy will improve to 3%.

For the rest of the numbers, I use seperate mneumonics. They are as follows:

The quarter steps past `1pi` and `2pi` are all at or near noteworthy whole numbers and fractions:

The quarter steps past 1.58 all end in 8. The 10th's place is sequential:

The scale appears as follows:

When I first memorized the scale, I was driving alone on a long car ride. There wasn't a lot I could do that was productive without becoming distacted, so I'd recite the scale to myself, occasionally referring to the copy of the slide rule above. By the end of the trip, I could recite the thing forwards and backwards. I was also able to recite the inverse of every quarter step, the log of every quarter step, and the multiples of every quarter step from 1 to 1.25. I recommend doing something similar for anyone interested in learning the system.

With greater precision, we find we can solve more complex problems.

We also find ourselves with better math reasoning skills.

And we find we can solve real world problems.

Calculating arrival times

Calculating tips

Converting inches to mm

Calculating sales tax

Trigonometry

Beyond quarter steps.

Make sure you start small. Start by remembering the half steps. Recite the scale forwards and backwards. Try your hand at multiplying, dividing, and exponentiating random numbers. I personally train with a scripting language like python or R, but a couple d10 or d20 dice work, too.

Once you have the basics down, you can memorize smaller increments to achieve greater accuracy.

First, you have to decide which increment you want to memorize. When you're memorizing a scale, it's important to start with an increment that accomplishes two things: 1.) it's easy to remember the scale, and 2.) it works well in base 10. A multiple like 1.1 is a great example. It's easy to calculate multiples of 1.1. For whole numbers, you just repeat the number twice, so for example `3 * 1.1 = 3.3`. For multiple digits, the first and last digit stay the same, and every other number gets added to it's neighbor, so for example `1.25 * 1.1` is:

So if we're memorizing the scale and we forget what an increment on our scale is, we can just multiply by some adjacent number that we do know. This won't excuse you from memorizing the thing, but it can help you while you memorize it.

We know `log_10(1.1) = 0.4`, so we can easily memorize a scale where every log increment is 0.2 since this would mean memorizing every fifth of a step. Since `log_10(1.05) = 0.2`, we know ever fifth step will represent a multiplication by 1.05.

Memorizing the first few steps of any scale will be critical, because any other step in the scale can be derived by multiplying one of the first steps and some whole number. Let's take a look at the first few fifth step increments

What sense can we make of them? Well, the trailing numbers are all very close to multiples of 0.05.

In other words, it's almost like we're adding 0.05 to each number. But that's not completely the case, because 1.259 rounds up to 1.26, and that's 1.20 + 0.06. By the time we've reached the first full step, it's like we're adding 0.06. Let's look at the next few fifth steps.

But that's not completely correct either, because by the time we reach 1.445 it's like we're adding by 0.07, and by the time we reach past 1.58, it's like we're adding by 0.08:

And of course the increment keeps increasing. The good news is this: it doesn't matter for our purposes. The error remains in line with the precision we want to accomplish. For us the mneumonic works just fine:

• In the first full step, the fifths steps increment by `~0.05`
• In the second full step, the fifths steps increment by `~0.06`
• In the third full step, the fifths steps increment by `~0.08`

Now, let's say you do want to memorize the fifths scale. You memorize the scale, paying particular attention to the steps from 1 to 1.25. As you did with the half steps, you ought to recite the scale and try your hand at some random problems. If you memorized the quarter steps, the fifth steps should come easier - the ¹/₅ and ⁴/₅ steps are only slightly off from the ¹/₄ and ³/₄ steps.

If we wish to go further, we can even remember every tenth of a step (multiplication by ~1.025). The tenth scale includes both the fifth step scale and the half step scale, so by the time you remember the half and fifth steps, you'll already have at least 6 of the 10 substeps memorized for each full step of the tenths scale.

The Tenths Scale: