# Maybe It’s Time to Retire Mathematical Notation I was helping my nephew with some math homework and he was stuck on a nasty looking formula. I explained it for several minutes, but it wasn’t working. Instead, I asked him the question using a running track as an example (he’s a runner). He instantly spit out the answer without hesitation. He understood the math, just not the notation.

Mathematical notation stinks. It makes easy concepts hard. It makes helpful concepts scary.

Most people break out in a cold sweat when shown a mildly complex mathematical expression. But here’s what’s fascinating…

Almost all math equations boil down to just a bunch of addition, subtraction, multiplication, and division.

It’s much like building with lego blocks. A child can stick two blocks together. There are only two things that prevent someone from building a large, complex lego structure (1) willingness to commit the time and (2) clarity of instructions. Lego sets generally have very good instructions, and so a child is only limited by their willingness to spend the time.

I argue that the same limits exist with math. I’d also argue that people give up quickly because the instructions are unclear and they lack confidence that they will succeed.

Unclear instructions are almost the staple of mathematics. They are on par with the assembly instructions that come with some knock off robot in the back of a Popular Science magazine.

## Math Notation Stinks

Those are some strong words for a standard that has been around for hundreds, even thousands of years. Let’s look at a simple example:

I offered my wife \$20 to calculate the answer. She has a college degree and has been taught these symbols during 16 years of education. She gave up after several minutes. I’m curious if you feel comfortable finding the answer?

To me, this syntax is a disaster. It is difficult to understand the intention, much less the actual process for calculating the answer.

Want to know the answer? Average the numbers 4, 2, and 6. That’s it. I’ll bet you can do it in your head. When put that way, my wife did it in 3 seconds.

## What Are The Shortcomings?

Here are the problems with math syntax. These are non-essential battles that every student must fight. Solving these problems would make math more approachable:

• Extra Work – the student must decompress and convert the equation into something they understand before evaluation even begins
• No Intention – the intention of the formula is almost never self documented
• Poor Naming – Meaningless, single letter variable names
• Nonsensical Memorization – Hundreds of symbols like ∑
• Wildly Inconsistent Syntax – nearly every symbol and operator has it’s own rules about order, meaning, and placement of parameters (such as subscript, superscripts, etc)
• Un-parsable – even computers have difficulty parsing a moderately complex equation
• Communication – Difficulty creating, editing, and communicating in modern tools like word processors, web pages, email, and chat

## So What’s The Solution?

I believe pseudocode would be better in nearly every way. Here the same equation from above using pseudocode:

```ages = [4, 2, 6]
average = sum(ages) / ages.count```

No doubt, there’s still a learning curve, but this syntax is far more intuitive. Clearly the goal is to calculate an average. We have words instead of meaningless single letter variables. Most people can look at it and know exactly what’s intended. Would you have ever guessed that from the first equation?

It would be beneficial for students to become more familiar with algorithms and coding basics. Using pseudo code would let us cross-train on several subjects that are very similar, but currently worlds apart in education.

Using named functions (like `sum` above) are a big key to bringing clarity. In this case, most students would know the meaning of `sum`. But if they didn’t then you would again use pseudocode to define the function `sum`. For example:

```function sum (items) {
total = 0
for (item of items)
total += item
}```

To be clear, there are many flavors of pseudocode around – many as bad as mathematical notation. Syntaxes with natural languages are the worst offenders. Pseudocode should be simple and predictable. No operator specific syntax. A cleaned up, trimmed down version of JavaScript.

Students could learn the entire grammar in a semesters and spend the rest of their education actually learning algorithm. As it stands, we are constantly learning new grammars. Is there anyone in the entire world that could even define a full grammar for the existing math notation?

## Extremely Complex Examples

This averaging example demonstrates a dramatic improvement, but it won’t always be this simple. For example, take a very common formula used in digital signal processing – the cooley-turkey equation for calculating a fast-fourier transform:

This equation is extremely dense and is frankly very difficult for me to understand – even as a math minor. Pseudocode is not going to magically make this simple, but I do believe that proper variable names and a decompressed format makes it more approachable.

```function fastForierTransform(samples) {
if (samples.count <= 1)
return samples
evenSamples = fastForierTransform(even(samples))
oddSamples = fastForierTransform(odd(samples))
half = samples.count / 2
amplitudes = []
for (k in 0 to (half - 1)) {
oddSample = oddSamples[k]
evenSample = evenSamples[k]
t = complex(0, -2 * PI * k / samples.count)
u = exp(t) * complex(oddSample, t)
amplitudes[k] = evenSample + complex(u, oddSample)
amplitudes[k + half] = evenSample - complex(u, evenSample)
}
return amplitudes
}```

At least a few things are clear – our function performs a ‘fastForierTransform’ – whatever that means. The input and output are at least labeled – samples in and amplitudes out. I can also see it is recursive and that odd and even signals are processed separately.

## Counterpoints

To offer a balanced argument, let’s look at some of the counterpoints:

• Math Notation would be hard to replace – 100% true. But look on the bright side, textbook companies could sell a bunch of new versions! Plus – schools just released “new math” – why not improve the grammar as well
• Math Notation is language agnostic – mostly true but there are several counter arguments:
• Why does math need to be language agnostic? So mathematicians can easily compare formulas with people who speak other languages? Why would we have children pay the tax to make an expert’s job easier?
• What we gain in clarity for students is worth so much more
• Current math notation isn’t actually 100% language agnostic right now – for example, most European countries use the comma as a decimal operator
• Programming languages are used all over the world, yet the code is always in english (for example `Math.cos`).
• Some small expressions become more noisy – the worst example, x3 would become `exp(x, 3)`. As a programmer I’ve learned that these tradeoffs happen all the time. Over time you learn that consistency and clarity are worth it – even if there are a few small efficiency losses here and there.
• Tricks (like Derivatives) – some tricks are specific to math notation – like `dy/dx x<sup>2</sup>` = `2x<sup>1</sup>` = `2x`. With pseudocode, this becomes `dx(exp(x, 2))` = `2 * exp(x, 1)` = `2 * x` which isn’t terrible.

I’m genuinely interested to get thoughts on this. Would love to do a study to actually determine validity. 