ALU — operations, flags (zero, carry, overflow, negative): Foundations

Before you can understand why the ALU raises the Carry flag but not the Overflow flag (or vice-versa), you have to be fluent in the raw vocabulary the parent note throws around: bits, MSB, $2^{n}$ , " $\sim$ ", $\oplus$ , "mod", and the idea of interpreting the same bits two different ways. We define each below, in the order they build on each other.

1. A bit — the atom

The picture: imagine one lamp. Off means $0$ , on means $1$ . That's a bit.

Why the topic needs it: the ALU's operands, its result, and every flag are all bits. If you can't picture one lamp, you can't picture the eight lamps that hold an 8-bit number.

2. A binary number and place value

Line up several lamps in a row. The parent note works with 8 bits (eight lamps). Reading them as a number requires place value.

Figure — ALU — operations, flags (zero, carry, overflow, negative)

Why the topic needs it: every operand ( $A$ , $B$ ) and result ( $R$ ) in the parent note is written as 8 lamps; place value is how you translate those lamps into the numbers $18$ , $255$ , $127$ , etc.

3. $n$ , and the notation $2^{n}$

Why does $2^{n}$ keep appearing? Because with $n$ lamps, each lamp independently ON/OFF, the number of different patterns you can make is $n times 2 \times 2 \times \dots \times 2 = 2^{n}$ .

The picture: a car odometer with $n$ wheels. It shows $2^{n}$ distinct readings before it rolls back to zero.

4. MSB and LSB — the most/least important lamp

The picture: in a row of 8 lamps, the far-left lamp ( $r_{7}$ , worth $128$ ) is the MSB; the far-right lamp ( $r_{0}$ , worth $1$ ) is the LSB.

Why the topic needs it: the Negative flag is literally the MSB ( $N = r_{n - 1}$ ), and carry/overflow are all about what happens at the MSB end of the row. Every flag lives near the MSB.

5. Signed vs unsigned — reading the SAME lamps two ways

This is the deepest idea on the page, and the whole reason there are two "too big" flags (Carry and Overflow).

Why the topic needs it: Carry watches the unsigned interpretation ("did we pass $255$ ?"); Overflow watches the signed interpretation ("did we leave $- 128..127$ ?"). Two readings ⇒ two flags. See Signed vs Unsigned Comparison Instructions for how branches use each.

6. The symbol $\sim$ — bitwise NOT (invert)

Why the topic needs it: two's complement negation is "invert and add one," $- x = (\sim x) + 1$ . The parent's subtraction trick $A - B = A + (\sim B) + 1$ leans entirely on this symbol.

7. "mod $2^{n}$ " — the wrap-around

The picture: the odometer again. When an 8-wheel odometer passes $255$ it doesn't show $256$ — it rolls back to $0$ . That rollover is "mod $256$ ."

Why the topic needs it: every ALU add/subtract silently happens "mod $2^{n}$ " because only $n$ lamps survive. The flags exist precisely to report the information that the mod threw away.

8. $\oplus$ — exclusive-OR (XOR)

$a$	$b$	$a \oplus b$
0	0	0
0	1	1
1	0	1
1	1	0

Why the topic needs it: the Overflow flag is $V = c_{n} \oplus c_{n - 1}$ — it fires exactly when the carry into the sign bit differs from the carry out of it. XOR is the perfect "are these two carries different?" detector.

A single slot holding exactly

0

1

; picture one lamp OFF/ON.

00010010

, what is the value?

16 + 2 = 18

(weights

2^{4}

and

2^{1}

Why does

2^{n}

appear everywhere?

With

n

bits there are

2^{n}

distinct patterns.

Which bit is the MSB in an 8-bit number?

The leftmost bit

r_{7}

, weight

2^{7} = 128

(or

- 128

signed).

Same lamps

11111111

: unsigned value and signed value?

255

unsigned,

- 1

signed.

What does

\sim x

do?

Inverts every bit (

0 \leftrightarrow 1

Compute

\sim 00000101

11111010

What does "mod

2^{n}

" mean physically?

Odometer rollover — discard everything above the top lamp.

When is

a \oplus b = 1

When

a

and

b

differ.

Carry-in vs carry-out of a column?

Carry-in arrives from the right; carry-out leaves to the left.

The Negative flag equals what?

The MSB of the result,

r_{n - 1}

What does "combinational" mean?

Output depends only on current inputs — no stored memory.

Foundations — ALU — operations, flags (zero, carry, overflow, negative)

1. A bit — the atom

2. A binary number and place value

3. $n$ , and the notation $2^{n}$

4. MSB and LSB — the most/least important lamp

5. Signed vs unsigned — reading the SAME lamps two ways

6. The symbol $\sim$ — bitwise NOT (invert)

7. "mod $2^{n}$ " — the wrap-around

8. $\oplus$ — exclusive-OR (XOR)

9. Carry-in and carry-out — how lamps talk to their neighbours

10. "Combinational" — no memory

How it all feeds the topic

Equipment checklist