Subtractors: Question bank — Hardware deep dive

Before we start, a quick vocabulary anchor so nothing below uses an undefined symbol:

True or false — justify

A half subtractor and a half adder produce the same difference/sum bit

True. Both are

A \oplus B

— the XOR (parity) of the two inputs. Only the carry vs borrow output differs, and that only by a bar over

A

The half-subtractor borrow

B_{o u t} = \overset{ˉ}{A} B

equals the half-adder carry

C = A B

False. They differ by the bar: borrow needs the top bit 0 (

\overset{ˉ}{A}

), carry needs it 1 (

A

). Check row

A = 0, B = 1

: borrow is 1 but

A B = 0

For

A - B

, a borrow-out occurs exactly when

A < B

in that column

True. In a single unsigned bit column,

A < B

means

A = 0, B = 1

, which is precisely the

\overset{ˉ}{A} B

condition for the half subtractor.

The difference bit of a full subtractor is 1 whenever an odd number of

A, B, B_{in}

are 1

True.

D = A \oplus B \oplus B_{in}

is the three-input parity function, which outputs 1 for exactly one or exactly three 1s.

Feeding

A + \overset{ˉ}{B} + 1

into an adder gives

A - B

and needs a dedicated subtractor circuit

False (the second half). It gives

A - B (mod 2^{n})

, and the whole point is you reuse the adder — no separate subtractor hardware is built.

A - B = A + \overset{ˉ}{B} + 1

, the trailing

+ 1

can be dropped if

B = 0

False. The

+ 1

is what converts one's complement (

\overset{ˉ}{B}

) into two's complement; drop it and every result is off by one, regardless of

B

Swapping to compute

B - A

instead of

A - B

just swaps which operand wears the bar in the borrow term

True.

A - B

borrows on

\overset{ˉ}{A} B

;

B - A

borrows on

A \overset{ˉ}{B}

. The "smaller top forces the borrow" rule flips accordingly.

The final borrow-out of a multi-bit subtraction being 0 means the answer is non-negative

True. A leftover borrow means the top number was smaller (

A < B

), so no final borrow signals

A \geq B

and a non-negative difference.

Spot the error

"Borrow for half subtractor is

A \overset{ˉ}{B}

because we take from

A

Wrong operand is barred. We borrow when the top bit can't cover the bottom, i.e.

A = 0, B = 1

, giving

\overset{ˉ}{A} B

A \overset{ˉ}{B}

is the row

A = 1, B = 0

, which needs no borrow.

"Full-adder carry is

C_{o u t} = A B + (A \oplus B) C_{in}

, so full-subtractor borrow is

A B + (A \oplus B) B_{in}

The

A

must become

\overset{ˉ}{A}

(and the XOR group gets a bar):

B_{o u t} = \overset{ˉ}{A} B + \overline{(A \oplus B)} B_{in}

. Copying the adder verbatim ignores that borrow needs a broke top bit.

"Two's complement of

B

is just

\overset{ˉ}{B}

That is one's complement. Two's complement is

\overset{ˉ}{B} + 1

; the missing

+ 1

is supplied as carry-in

= 1

on the adder.

"Since

D = A \oplus B

, the half subtractor and half adder are literally the same circuit."

They share the XOR difference/sum gate but differ on the second output: adder produces carry

A B

, subtractor produces borrow

\overset{ˉ}{A} B

. Different gate feeding that output, so not the same circuit.

"In

6 - 3

the final (bit-2) borrow was 1, so the answer must be negative."

The bit-2 borrow-out was 0 for

6 - 3

; a 0 final borrow means

A \geq B

so the result is non-negative. A 1 there would signal a negative (wrap-around) result.

"To make an adder subtract, invert

A

instead of

B

You invert the subtrahend

B

(via XOR gates controlled by one line) and set carry-in to 1. Inverting

A

would compute

\overset{ˉ}{A} + B + 1 = B - A

, the wrong direction.

Why questions

Why is the borrow called "borrow" and not "carry"?

In addition an overflow is pushed up as a carry; in subtraction a shortage pulls a value down from the next column, so the higher column then "owes one" — that owed note travels out as the borrow.

Why does borrowing add exactly

2

(not

10

) to the current column?

This is binary, so one unit of the next-higher place is worth

2

. Borrowing that bundle turns a

0 - 1

shortfall into

0 + 2 - 1 = 1

Why is the full-subtractor difference an XOR of three inputs rather than something more complex?

The difference bit only cares about parity — whether the running subtraction leaves the least bit set. An odd count of 1s among

A, B, B_{in}

leaves a 1, which is exactly three-input XOR.

Why do real CPUs not build a dedicated subtractor at all?

Because

A - B = A + \overset{ˉ}{B} + 1

lets one adder do subtraction by inverting

B

and setting carry-in to 1; a single control line turns the same hardware into an adder or subtractor, saving gates.

Why does a borrow-out from the two-stage view equal

b_{1} + b_{2}

(OR) and not

b_{1} \cdot b_{2}

A borrow is needed overall if either internal subtract needed one, so it's a logical OR of the two stage borrows, not an AND.

Why does replacing

A

with

\overset{ˉ}{A}

turn the adder's carry formula into the subtractor's borrow formula?

Carry "generates" when both bits push a 1 upward (

A B

); borrow "generates" when the top bit is missing while the bottom demands (

\overset{ˉ}{A} B

). The structural roles match; only the top-bit polarity flips.

Edge cases

Half subtractor with

A = 0, B = 0

: is there ever a borrow?

No. Nothing is being taken away (

0 - 0 = 0

), so

D = 0

and

B_{o u t} = \overset{ˉ}{0} \cdot 0 = 0

. The degenerate empty column.

Full subtractor with all inputs 1 (

A = B = B_{in} = 1

): why is borrow still 1 even though

A = 1

We compute

1 - 1 - 1 = - 1

, which needs a borrow. The incoming borrow (

B_{in}

) alone exceeds what's left after

A - B

, so the

B B_{in}

term fires and

B_{o u t} = 1

Column where

A = 1, B = 0, B_{in} = 1

: does the incoming borrow force a borrow-out?

No.

1 - 0 - 1 = 0

exactly, so it consumes the borrow-in without needing to borrow further:

D = 0, B_{o u t} = 0

What does a final borrow-out of 1 after subtracting two same-width numbers mean?

It means

A < B

, so the true difference is negative; in fixed-width two's-complement arithmetic the result has wrapped around by

2^{n}

Multi-bit subtraction: what must the borrow-in to the lowest (LSB) full subtractor be?

It must be 0 — there is no column below the least significant bit to owe anything, so the chain starts with

B_{in, 0} = 0

Subtracting a number from itself,

A - A

, across all bits: what are all the difference and borrow bits?

Every column has equal bits (

A = B

), so each

D = A \oplus A = 0

and each

B_{o u t} = 0

— a clean zero result with no borrow anywhere.

Two's-complement route for

A - B

when

A = B

: does the discarded carry-out appear?

Yes.

A + \overset{ˉ}{A} + 1 = 2^{n}

, whose

2^{n}

is exactly the carry-out you throw away, leaving difference

0

— matching the direct subtractor's all-zero result.

Connections

Subtractors — the parent note these traps drill.
Adders — every "adder vs subtractor" trap traces back to the shared XOR and the barred $A$ .
Twos-Complement-Representation — source of the $\overset{ˉ}{B} + 1$ and the discarded $2^{n}$ carry.
Adder-Subtractor-Circuit — the "one control line, invert $B$ , carry-in 1" traps live here.
XOR-Gate — parity intuition behind both difference and controlled inversion.
Ripple-Carry-Chains — the multi-bit borrow-propagation edge cases.