# How to avoid arithmetic mistakes?

When dealing with several numbers and long equations, it's common to make careless arithmetic mistakes that give the wrong answer. I was wondering if anyone had tips to catch these mistakes, or even better avoid them more often. (aside from the obvious checking your work- that's a must)

-

4
More practice and calm state of mind. – Tomarinator Apr 29 '12 at 7:11

1
Start with positive thinking: it's not common to make careless arithmetic mistakes that give the wrong answer. It works. :) – sai Apr 29 '12 at 7:21

2
Also, apparently 'don't do arithmetic before you've had your morning coffee'... – Steven Stadnicki Apr 29 '12 at 17:09

4
Just another tiny tip: if the things you're performing arithmetic on have units, keep the units on, and make sure the units of the result you get do make sense. So, you can't add feet and meters directly, and if you're expecting a result in mass units and you get something in square meters per kilogram, something went quite wrong. – J. M. Apr 29 '12 at 17:37

4
Neatness helps a lot. Write clearly. Keep things in columns. Don't try to cram too much onto the page. Don't try to do too much in your head (i.e. write out each step). As you use terms to get to the next line, check them off or underline them. – Tpofofn Apr 29 '12 at 22:24
show 4 more comments

## 13 Answers

There are certain quick methods called sanity checks which will catch most (but not all) arithmetic errors. One common one is to replace each number with the sum of its digits, which is the "casting out nines" method mentioned in Robert Israel's answer. To check a computation, say $567\times 894=506,898$, we replace $567$ with $5+6+7=18$ and $894$ with $8+9+4=21$, and then replace each of these with the sum of their digits to get $9$ and $3$ (in general we keep doing this until we get down to $1$ digit), while on the other side we get $5+0+6+8+9+8=36$ and then $3+6=9$. We then check that $9\times 3=9$ after casting out nines on both sides, and so our answer is probably right (though not necessarily). This method is called "casting out nines" because it ensures that whatever answer you are checking differs from the actual answer by a multiple of nine (hopefully $0\times 9$).

However, this method has a serious drawback: if the answer you are checking is correct except for having the digits switched around (a relatively common error) the method will not catch the error. A remedy for this is to use "casting out elevens" where you take the alternating sums of the digits instead of the sums, such that the last digit is always added rather than subtracted. In our previous example, this becomes $5-6+7=6$, $8-9+4=3$ and $5+0-6+8-9+8=-4$. Here we have to be a little careful: we want to take the equation $6\times 3-(-4)=0$, cast out elevens (take the alternating sum) and verify that the the resulting equation holds, which in this case it does. We move everything to one side so that we don't have to work with numbers of different signs ($6\times 3=-4$ is true $\bmod 11$, which is what matters, but it is not obvious how to cast out elevens to show this). This ensures that whatever answer you are checking differs from the actual answer by a multiple of eleven (hopefully $0\times 11$), hence the name.

Edit: These methods can both be made rigrous with modular arithmetic. The first simple checks that an equation holds $\bmod 9$, and adding the digits comes from the fact that $$\begin{eqnarray} d_n\cdots d_1d_0 &=& \sum\limits_{i=1}^n 10^id_i\\ &\equiv& \sum\limits_{i=1}^n 1^id_i (\bmod 9)\\ &=&\sum\limits_{i=1}^n d_i \end{eqnarray}$$ while the second checks that an equation holds $\bmod 11$, and the alternating sum of the digits comes from the fact that $$\begin{eqnarray} d_n\cdots d_1d_0 &=& \sum\limits_{i=1}^n 10^id_i\\ &\equiv& \sum\limits_{i=1}^n (-1)^id_i (\bmod 11) \end{eqnarray}$$

Credit where credit is due: I believe I read about this years ago in a question to Dr. Math from an elementary school teacher who had been teaching the method and wanted to know how it worked.

-

1
5 + 6 + 7 = 18, so I'm not really sure how that affects the rest of the first half – DHall Apr 29 '12 at 14:24
@DHall - It still works, because 5+6+7=18 and 18 ≡ 0 mod 9, and 0 x 3 = 0 and 9 ≡ 0 mod 9. You should recognize that casting out nines will silently work with an arithmetic mistake 1/9 times. – dr jimbob Apr 29 '12 at 16:01
@DHall It seems even with this method, I make arithmetic mistakes. – Alex Becker Apr 29 '12 at 17:31
There are several types of arithmetic mistake where casting out nines is particularly unhelpful - especially, a digit transposition (very common type of error), or when multiplying by 9 or 3. – Ronald Apr 29 '12 at 20:52

2
@qwertymk If you're familiar with modular arithmetic, it is much better explained as: check your calculation $\mod 11$, which is easy to do by alternating sums. It certainly seems artificial if you haven't seen modular arithmetic. – Alex Becker Apr 30 '12 at 4:36
show 5 more comments

In my experience, the best way to avoid computational errors is to avoid computation. Develop general algorithms for whatever quantity that you are looking for and then proceed to "plug and chug" as the last step. Mathematics requires precision, however, and you often cannot avoid having to comb over your work tediously.

-
Definitely the best trick... +1! Even great mathematicians make computational mistakes ; the brain is just never going to be as efficient as a computer. – Patrick Da Silva Apr 29 '12 at 7:26

16
@Ronald: please don't do that. I see way too many students that are lost without a calculator, even for simple matters. – nico Apr 29 '12 at 13:36

5
There's something a bit sad about seeing a teener reaching for a calculator for $8\times 3$... – J. M. Apr 29 '12 at 17:32

1
In an exam/pressure situation, where you have a calculator available to you, it's really unquestionably the best strategy to avoid mental arithmetic. I make that clear to students, and I wouldn't be doing my job properly if I didn't. Sorry. They can all do $8\times3$, but they shouldn't be risking an arithmetic mistake during an examination on e.g. linear algebra. Mathematics is not arithmetic. @J.M. Actually $8\times3$ is not really a problem - I'm usually more concerned about $1\times1$ and $1\times0$. – Ronald Apr 29 '12 at 19:48

5
Relevant anecdote: an economics professor I knew used to keep track of the stupidest things students asked for a calculator for. His best was $120/1$. – Alex Becker Apr 29 '12 at 22:12
show 2 more comments

I have found the best way to avoid these types of computational mistakes is:

1. To have extremely neat and clear handwriting.

2. To effectively use the space on the page to organize the work in a logical manner.

3. Use a pencil. Never cross things out, but erase them instead.

4. Always take the time to think things through slowly and carefully.

5. Keep your desk very neat and well organized.

I believe that if you write things down in a clear way, then you will think in a clear way; and if you write in a sloppy way, you will think in a sloppy way.

-

2
Interesting: instead of 4, I recommend its direct opposite: use a pen, and if something is wrong, cross it out with a light line, in case it should turn out to have been right after all. I also follow the rule: never “cancel”, but just write a little more. – Lubin Apr 29 '12 at 17:29

1
The good thing about using a pen is that 1. you might have been right all along, and you wouldn't see that if you've erased the thing; and 2. you can look at it again when all is said and done, and note what not to do the next time. It keeps you honest, too, knowing that you did struggle a bit for solving it, and it wasn't as sleek as it otherwise would have looked. – J. M. Apr 29 '12 at 17:35

4
On an exam, one of my students wrote a full-page answer to a question, then (apparently) realized something was wrong, and very carefully erased the whole page. Unfortunately, by that time the exam was over... – Robert Israel Apr 29 '12 at 18:41

2
Agree with other commenters that erasing is not necessarily a good idea - a single, neat line is a better option. – Ronald Apr 29 '12 at 20:49

In my opinion, for research, use a computer. Your brain is just never going to be perfect.

For exams, though, go through the common computations lots of times before an exam, for instance if you have a linear algebra exam, it is wise to compute matrix inverses a few times (say like 20-40 times depending on your brain's capacity to compute) to be at ease with the algorithmic details and be able to focus on the numbers more easily during computation.

But then again, even if you've practiced for a week, a month later, I've already lost the habit of computing the thing in question and start abusing my brain like nuts to compute...

Hope that helps!

-

One simple tool that catches many arithmetic mistakes is "casting out nines". See http://en.wikipedia.org/wiki/Casting_out_nines

-

1
It seems like its more likely to make a mistake while casting out nines. ;) – Tomarinator Apr 29 '12 at 7:16

2
Personally I don't like to verify if my solution is okay by looking at a quotient of my solution... I might be off from the solution by a $9$-multiple! – Patrick Da Silva Apr 29 '12 at 7:25

One way to check arithmetic calculations in a ring is to map the computation homomorphically into rings where calculation is easier. For example, many rings have parity, i.e. have $\mathbb Z/2$ as an image, and mapping the arithmetic mod $2$ yields a simple parity check that often catches errors. Casting nines is another example of a modular arithmetic check (which also works for fractions whose denominator is coprime to $9$). More generally one can verify equalities using a sufficient number of modular checks, by employing CRT (Chinese Remainder). For polynomial rings one can similarly apply evaluation maps as checks. Again, with enough evaluations, one can verify equalities (which here is CRT = Lagrange interpolation).

Like CRT, such factorizations or decompositions of an algebraic structure into simpler structures is a powerful problem-solving technique, applicable not only to checking arithmetic, but also quite generally. It is the algebraists way to divide-and-conquer. When combined with a little logic this yields even greater power. One nontrivial example is the model-theoretic proof of Jacobson's theorem, that rings satisfying the identity $\rm\:x^m = x \:$ are commutative. This proceeds by a certain type of ring factorization, which reduces the problem to the (subdirectly) irreducible rings satisfying the identity. These turn out to be certain finite fields, which are commutative, as desired. In a sense, the proof works by exploiting the fact that the statement need only be checked on a certain set of simpler cases (finite fields), where the verification is much easier. Thus this can be seen as a grand generalization of the ideas employed in the more elementary cases above.

-

As mentioned in other answers computers are very good at arithmetic. If such devices are not available try to calculate the answer in several different ways or at least do the steps in a different order. If you always get the same answer it is likely to be correct. If the answers are different investigate the source of the difference. Casting out nines will not catch transposition errors but it will catch carrying errors.

After writing the above I recalled this graphical method of multiplication: Multiplication by counting points .

-

I often apply a simple intuitive check at the end of my calculations to make sure that at the coarsest level the answer makes sense.

For example:

• Am I expecting the answer to be a larger or smaller number than the input values? by how many orders of magnitude?
• Should the answer be positive or negative?
• Does it makes sense that the answer is between 0 and 1 (or greater than 100, etc...)?

While these checks are not as sensitive as some of the other examples, they can catch a lot of careless mistakes and have the advantage of forcing one to think about and understand what the calculations are doing and what type of answer should make sense.

-

You should also check out Vedic maths

-

You can always use all kinds of computer applications, but those only help you if you have them around.

I suppose that you're talking about making calculations on paper or in head, and I would have one suggestion here, which proved to be more than excellent for me.

It's quite simple: concentration, concentration, concentration.

You have to think about what you're computing, and nothing else. It may sound stupid, but you will be suprised about your own mental power if you stay in absolute focus.

Good luck!

-

I use checksums for memory operations.

A simple example is whenever my wife gives me a long verbal list of groceries to buy, I count the total. If a big number say > 20 items, then split into 3 categories. If I pretend a simple sum is easy to remember for short term memory, then I can accumulate or count down until the process ( in this case; simple remember, search and fetch) as long as I remember the total number of items, I rarely forget one. For fun I may remember the word I can spell with the 1st letter of each item. This gives more redundancy and checksum info in an easy way to remember.

The challenge is to count brackets, variables & transforms and visualize the process as your checksums.

-

One technique that's under-hyped is to simply redo the calculation on a separate sheet of paper without looking at your prior calculations. You are still vulnerable to committing the same error but it'll catch frivolous one's quite well.

-

Absolutely! It’s happened all too frequently that I just could not find my error, even though I knew there was one, and I turned it up by just this method. – Lubin May 10 '12 at 3:02

When doing algebraic computations, for example when finding the partial fraction decomposition of a certain expression, something I find helpful is to substitute a certain number and see if the two expressions match.

For example to "verify" $\frac{1}{(1+x)(5+x)}=\frac{1}{4(x+1)}-\frac{1}{4(x+5)}$, you may want to substitute in some value of x, say $x=9$, and see that both sides become $1/140$.

-
{"extraction_info": {"found_math": true, "script_math_tex": 0, "script_math_asciimath": 0, "math_annotations": 0, "math_alttext": 0, "mathml": 0, "mathjax_tag": 0, "mathjax_inline_tex": 36, "mathjax_display_tex": 2, "mathjax_asciimath": 0, "img_math": 0, "codecogs_latex": 0, "wp_latex": 0, "mimetex.cgi": 0, "/images/math/codecogs": 0, "mathtex.cgi": 0}, "config": {"markdown_headings": true, "markdown_code": true, "boilerplate_config": {"ratio_threshold": 0.18, "absolute_threshold": 10, "end_threshold": 15, "enable": true}, "remove_buttons": true, "remove_image_figures": true, "remove_link_clusters": true, "table_config": {"min_rows": 2, "min_cols": 3, "format": "github"}, "remove_chinese": true, "remove_edit_buttons": true, "extract_latex": true}, "english_confidence": 0.948474109172821, "perplexity_flag": "middle"}