Russian Peasant Multiplication: The Ancient Method That Uses Only Doubling and Halving

Russian Peasant Multiplication is one of the oldest computational algorithms in recorded history — versions of it appear in the Egyptian Rhind Papyrus from around 1650 BCE — and it’s also one of the cleanest ways to teach binary representation to a student who has never seen base-2 arithmetic. The algorithm is mechanically simple: halve one number, double the other, ignore rows where the halved number is even, sum the remaining doubled values. The result is the product. The reason it works is the reason every computer in the world multiplies the way it does: every integer has a unique binary expansion. This guide walks through the method, the worked example, the proof of correctness, and the connection to how CPUs actually perform multiplication.

Multiplication is probably the most important elementary operation in mathematics. Every math enthusiast develops their own preferred techniques over time.

But have you ever multiplied two numbers using only doubling and halving? No multiplication tables required?

This method has been around for thousands of years. The ancient Egyptians used it. Russian peasants passed it down through generations (hence the name). And it’s still fascinating today because it reveals a deep connection between arithmetic and binary numbers.

Let me show you how it works.

Why Russian Peasant Multiplication Works — The Binary Connection

The method works because every positive integer has a unique binary representation. When you repeatedly halve a number (discarding the remainder), the sequence of remainders — read bottom-to-top — is the binary representation of the original number. Each “keep this row” decision corresponds to a 1-bit in the binary expansion. Each “discard this row” decision corresponds to a 0-bit. The doubled values you add up are the powers-of-2 multiples of the second number, selected by the binary digits of the first.

Worked example for \( 13 \times 17 \): binary of 13 is 1101. Powers-of-2 multiples of 17 are \( 17, 34, 68, 136, \ldots \) corresponding to \( 2^0, 2^1, 2^2, 2^3 \). The 1-bits of 1101 are at positions 0, 2, 3, so we sum \( 17 + 68 + 136 = 221 \). And indeed \( 13 \times 17 = 221 \). The Russian peasant table you’d write out by hand does exactly this computation, just without ever naming the binary representation explicitly.

This is the algorithm modern computers use internally — modulo low-level optimizations like Booth’s algorithm and Wallace tree adders, every digital multiplication ultimately reduces to “for each 1-bit in the multiplier, add the appropriate shifted version of the multiplicand.” A 4,000-year-old Egyptian doubling method is what your phone is doing every time it multiplies two integers.

The Method in Action: 48 × 35

Let’s multiply 48 by 35 using this technique.

Step 1: Set Up Two Columns

Write your two numbers in separate columns, side by side.

Put 48 in the left column and 35 in the right column. (It doesn’t actually matter which number goes where – the result is the same.)

Step 2: Double the Left, Halve the Right

Now comes the core operation:

• Left column: Keep doubling (multiply by 2)
• Right column: Keep halving (divide by 2, dropping any remainder)

Continue until the right column reaches 1.

Here’s what happens:

Left (×2)	Right (÷2)
48	35
96	17
192	8
384	4
768	2
1536	1

Important: When halving odd numbers, drop the fraction. 35 ÷ 2 = 17.5 becomes just 17. We only work with whole numbers.

Step 3: Cross Out Rows Where Right Column is Even

Look at the right column. Any row where the right number is even gets crossed out entirely.

Left	Right	Keep?
48	35	✓ ODD
96	17	✓ ODD
192	8	✗ EVEN
384	4	✗ EVEN
768	2	✗ EVEN
1536	1	✓ ODD

Notice that the last row (where right = 1) is always kept, since 1 is odd.

Step 4: Sum the Remaining Left Column Numbers

Add up all the left-column numbers that weren’t crossed out.

48 + 96 + 1536 = 1680

And there’s your answer: 48 × 35 = 1680 ✓

The Complete Process at a Glance

Here’s the entire method visualized in one diagram:

Why Does This Actually Work?

This isn’t magic – it’s binary arithmetic in disguise.

When you halve numbers and check if they’re odd or even, you’re essentially reading the binary representation of that number. Each “odd” row corresponds to a 1 in the binary representation; each “even” row corresponds to a 0.

Let’s break it down:

35 in binary = 100011

This means: 35 = 32 + 2 + 1 = 2⁵ + 2¹ + 2⁰

So when we multiply 48 × 35, we’re really computing:

• 48 × 32 = 1536 (row 6, right column = 1, which is odd)
• 48 × 2 = 96 (row 2, right column = 17, which is odd)
• 48 × 1 = 48 (row 1, right column = 35, which is odd)

Total: 1536 + 96 + 48 = 1680

The rows we kept correspond exactly to the powers of 2 that make up 35!

Another Example: 88 × 45

Let’s verify with another calculation.

Left (×2)	Right (÷2)	Keep?
88	45	✓ ODD
176	22	✗ EVEN
352	11	✓ ODD
704	5	✓ ODD
1408	2	✗ EVEN
2816	1	✓ ODD

Sum: 88 + 352 + 704 + 2816 = 3960

Check: 88 × 45 = 3960 ✓

When Would You Actually Use This?

I’ll be honest – you’re not going to use this for everyday calculations. It’s longer than standard multiplication once you know your times tables.

But this method is valuable for:

1. Teaching binary concepts – It makes binary numbers tangible
2. Computer science education – This is essentially how computers multiply
3. Historical appreciation – The Egyptians used this 4,000 years ago
4. Mental math party tricks – Impress friends by multiplying without knowing any multiplication facts beyond doubling
5. Backup method – If you only know how to double and halve, you can multiply anything

Try It Yourself

Practice with these:

1. 23 × 17 = ?
2. 56 × 43 = ?
3. 127 × 89 = ?

Work through the table, cross out even rows, sum what remains.

The Beauty of Ancient Mathematics

What amazes me about this method is that ancient Egyptians discovered an algorithm that modern computers essentially still use. They didn’t know about binary numbers or computer science – they just found a pattern that worked.

The fact that doubling, halving, and checking for odd/even naturally decomposes into binary multiplication is one of those beautiful coincidences in mathematics that feels almost inevitable in hindsight.

Try it a few times. Once you see the pattern, you’ll never forget it.