Binary Addition and Logical Shifts

Binary addition works column by column from right to left — exactly like denary addition, but the carry threshold is 2, not 10. There are only four possible column outcomes.

Column inputs	Binary result	Digit written	Carry to next column
0 + 0	0	0	0
0 + 1	1	1	0
1 + 1	10	0	1
1 + 1 + 1	11	1	1

The fourth rule (1 + 1 + 1) matters when two operand bits are both 1 and a carry also arrives from the previous column. AQA 8525 exam questions involve at most three 8-bit numbers and will never have more than three 1s in any single column.

Write the carry row above the addition before working any column — doing it mentally causes almost all binary addition errors.

Work from the rightmost column to the leftmost, using the four rules and propagating any carry one column left.

Worked example — add 00110101 (53) and 00011010 (26):

  carry: 0 1 1 0 0 0 0 0
         ─────────────────
         0 0 1 1 0 1 0 1   (53)
       + 0 0 0 1 1 0 1 0   (26)
         ─────────────────
         0 1 0 0 1 1 1 1   (79)

Column trace (right to left):

Col	Bits	Carry in	Sum	Write	Carry out
0	1+0	0	1	1	0
1	0+1	0	1	1	0
2	1+0	0	1	1	0
3	0+1	0	1	1	0
4	1+1	0	2	0	1
5	1+0	1	2	0	1
6	0+0	1	1	1	0
7	0+0	0	0	0	0

Result: 01001111 = 64 + 8 + 4 + 2 + 1 = 79 ✓ (53 + 26 = 79)

In AQA 8525 questions, you will only need to add a maximum of three 1s in any single column, including any carry. This means the four rules from the first slide are enough.

Worked example — add 00010111 (23), 00001010 (10), and 00000101 (5):

  00010111   (23)
  00001010   (10)
+ 00000101   (5)
──────────
  00100110   (38)

Key column traces where carries propagate:

Col	Bits	Carry in	Sum	Write	Carry out
0	1 + 0 + 1	0	2	0	1
1	1 + 1 + 0	1	3	1	1
2	1 + 0 + 1	1	3	1	1
3	0 + 1 + 0	1	2	0	1
4	1 + 0 + 0	1	2	0	1
5	0 + 0 + 0	1	1	1	0

Result: 00100110 = 32 + 4 + 2 = 38 ✓ (23 + 10 + 5 = 38)

The AQA 8525 spec requires you to describe situations where binary shifts are useful. Both directions apply wherever a value needs to be multiplied or divided by an exact power of 2.

Situation	Direction	Example
Multiply by a power of 2	Left shift by $n$	× 8: left shift 3
Divide by a power of 2	Right shift by $n$	÷ 4: right shift 2
Scaling pixel brightness values	Right shift	Halve all pixel values: right shift 1
Fast arithmetic on hardware with no multiply instruction	Left or right shift	Embedded controllers, early CPUs

Worked example — multiply 5 by 8 using a left shift ($2^3=8$):

Step	Bits	Value
Original	00000101	5
Left shift 3	00101000	40

$5\times 2^3=5\times 8=40✓$

Worked example — divide 100 by 4 using a right shift ($2^2=4$):

Step	Bits	Value
Original	01100100	100
Right shift 2	00011001	25

$100÷2^2=100÷4=25✓$

Shifts only substitute for multiplication or division by exact powers of 2. To multiply by 6 or divide by 3, a single shift is not sufficient.

A logical left shift moves every bit a fixed number of positions to the left. Vacated positions on the right are filled with 0. Bits that shift beyond the leftmost position are permanently lost.

Effect on value: shifting left by $n$ positions multiplies the value by $2^n$, provided no significant bits fall off the left edge.

Worked example — shift 00000011 (3) left by 2:

Step	Bits	Value
Original	00000011	3
Left shift 1	00000110	6
Left shift 2	00001100	12

$3\times 2^2=3\times 4=12✓$

Processors use left shifts for fast multiplication by powers of 2 because a shift is far cheaper than a full multiplication instruction. If 11000000 (192) is shifted left by 1, the leading 1 falls off the boundary: the stored result is 10000000 (128), not 384. The most significant bit was lost, making the result incorrect.

A logical right shift moves every bit a fixed number of positions to the right. Vacated positions on the left are filled with 0. Bits that shift off the right end are permanently lost.

Effect on value: shifting right by $n$ positions divides the value by $2^n$, discarding any remainder (integer division — it always rounds down).

Worked example — shift 00011000 (24) right by 2:

Step	Bits	Value
Original	00011000	24
Right shift 1	00001100	12
Right shift 2	00000110	6

$24÷2^2=24÷4=6✓$

Truncation — shift 00001101 (13) right by 1:

• Result: 00000110 = 6
• The rightmost 1 (worth 1) falls off and is lost
• 13 ÷ 2 = 6.5; the binary right shift gives 6 — the fractional part is discarded, not rounded

Right shift performs integer division. Any bits lost on the right are gone permanently.

1. Not writing the carry row

Carrying mentally is the single most common source of column errors in binary addition. Write the carry row above the sum as the first step, before calculating any column result.

2. Stopping the carry chain too early

After a carry is generated, it must be added into the next column. If that next column then also produces a carry, that carry must propagate further left. Do not assume the carry only affects one column.

3. Claiming shifts work for any multiplier or divisor

Left and right shifts only multiply or divide by exact powers of 2 (1, 2, 4, 8, 16, …). To multiply by 6, for example, you need a combination of shifts and addition — not a single shift. Describing a shift as "multiply by any number" is incorrect.

4. Treating right shift as exact division

Binary right shift performs integer division with truncation. Shifting 00001101 (13) right by 1 gives 6, not 6.5. Any odd-valued bits on the right edge that fall off are simply lost.

5. Applying the shift-as-multiplication shortcut when a significant bit would be lost

A left shift only produces the correct multiplication result if no 1-bit falls off the left edge. The Logical Left Shift slide shows 11000000 (192) shifted left by 1 giving 10000000 (128) instead of 384. Before using a shift to multiply, check that the original value is small enough that all significant 1-bits remain within 8 positions after shifting.