Binary Addition Rules Explained with Examples

Binary addition rules explain how to add numbers in the base‑2 system using only the digits 0 and 1. Essential for computing and digital logic, these rules yield a Sum (S) and a Carry (C) and reduce to four basic cases: 0+0, 0+1, 1+0, and 1+1 (producing a carry). This guide breaks down each case with clear steps, practical tips for tracking frequent carries and borrows and concise worked examples to build speed and accuracy. Ideal for students to master binary addition for exams and real‑world applications.

Table of Contents

• What Is Binary Addition?
• The 4 Rules of Binary Addition
• Solved Examples on Binary Addition Rules
• Adding Signed Binary Numbers
• Frequently Asked Questions of Binary Addition Rules

What Is Binary Addition?

Binary addition is the process of adding two or more binary numbers, which are numbers represented using only the digits 0 and 1. The process of binary addition is similar to decimal addition, but it follows a different set of rules because binary has only two digits. 

The 4 Rules of Binary Addition

Binary addition follows four rules:

• 0 + 0 = 0
  No carry

• 0 + 1 = 1
  No carry

• 1 + 0 = 1
  No carry

• 1 + 1 = 10

Write 0, carry 1

There's actually a fifth case: when a column already has a carry coming in.

1 + 1 + 1 = 11

Write 1, carry 1 (two bits plus an incoming carry)

Binary Addition Table

Step-by-Step Method

Work from right to left, one column at a time, exactly as you would with decimal numbers:

• Align both numbers by their rightmost digit (pad with leading zeros if the numbers have different lengths).

• Add the rightmost column using the rules above.

• If the sum is 10 (in binary), write 0 and carry 1 to the next column.

• Move to the next column and add its two digits plus any carry from the previous column.

• Repeat until every column is done. If there's a carry left over after the last column, write it as a new leading digit.

Example: 1010 + 0101

  1010

+ 0101

------

  1111

No column reaches 2, so there's no carry anywhere. Cross-check: 1010 = 10,

0101 = 5 and 10 + 5 = 15 = 1111 in binary.

Solved Examples on Binary Addition Rules

Example 1: 1011 + 1101

Solution: 

    1 1 1     (carries)

   1 0 1 1

+  1 1 0 1

-----------

 1 1 0 0 0

Column by column: 1+1=10 (write 0, carry 1); 1+0+1=10 (write 0, carry 1); 0+1+1=10 (write 0, carry 1); 1+1+1=11 (write 1, carry 1); final carry becomes a new leading 1. 

Cross-check: 11 + 13 = 24 = 11000.

Example 2: 0111 + 0001 

Solution: 

  1 1 1     (carries)

   0 1 1 1

+  0 0 0 1

-----------

   1 0 0 0   

Cross-check: 7 + 1 = 8 = 1000.

Example 3: 101 + 110 + 111

Solution: 

Step 1: 101 + 110 = 1011   (5 + 6 = 11)

Step 2: 1011 + 111 = 10010  (11 + 7 = 18)

When you need to add three or more binary numbers, add any two first, then add the result to the next number, repeating until only one number remains. Cross-check: 5 + 6 + 7 = 18 = 10010.

Larger numbers

Example 4: 11010 + 10111

Solution: 

   1 1 1 1    (carries)

   1 1 0 1 0

+  1 0 1 1 1

-------------

 1 1 0 0 0 1

Cross-check: 11010 = 26, 10111 = 23 and 26 + 23 = 49 = 110001 in binary.

Adding Signed Binary Numbers

So far, we have considered only positive binary numbers. To represent negative numbers, computers use 1's complement and 2's complement, with 2's complement being the standard method used in modern computer systems.

How 2's complement works

To represent a negative number: write the positive number in binary, flip every bit (0s become 1s and vice versa), then add 1 to the result.

Example: Add +9 and −5 using 8-bit 2's complement

+9  =  0 0 0 0 1 0 0 1

 5  =  0 0 0 0 0 1 0 1

Flip bits:   1 1 1 1 1 0 1 0

Add 1:       1 1 1 1 1 0 1 1   ← this represents −5

Now add +9 and −5:

   0 0 0 0 1 0 0 1

+  1 1 1 1 1 0 1 1

-------------------

 1 0 0 0 0 0 1 0 0   ← the leading 1 is a carry-out beyond 8 bits, and is simply discarded

Result: 0 0 0 0 0 1 0 0  =  4

And indeed, +9 + (−5) = 4. The carry generated past the 8th bit is expected and gets discarded; that's a normal, correct part of 2's complement arithmetic, not an error.