Comparators: Question bank — Hardware deep dive

Notation used below (all built in the parent Comparators):

$A, B$ — the two unsigned binary numbers being compared.
$G, E, L$ — the outputs " $A > B$ ", " $A = B$ ", " $A < B$ ".
$A_{i}, B_{i}$ — bit $i$ (bit $0$ is the least significant, LSB; the top bit is the most significant, MSB).
$x_{i} = \overline{A_{i} \oplus B_{i}}$ — the per-bit equality flag, high when bit $i$ of both numbers matches.
$\overset{ˉ}{B}$ — NOT $B$ ; $\oplus$ — XOR ("differ"); $\overline{A \oplus B}$ — XNOR ("same").

True or false — justify

A raw XOR gate on two bits gives you an equality signal.

False. XOR outputs

1

when the bits differ, so it is an inequality detector; equality is its negation,

\overline{A \oplus B}

(XNOR).

For unsigned numbers,

100 0_{2} > 011 1_{2}

even though

B

has more

1

s in it.

True. Magnitude is set by the MSB, not by counting ones:

100 0_{2} = 8

and

011 1_{2} = 7

. The single high MSB of

A

outweighs all three low bits of

B

In an

n

-bit comparator, the outputs always satisfy

G + E + L = 1

True. For any two numbers exactly one of "greater", "equal", "less" holds, so precisely one output is high — the three are mutually exclusive and exhaustive.

You could build a 4-bit comparator by writing a single truth table and reading off minterms.

True in principle, terrible in practice. It needs

2^{8} = 256

rows; the MSB-first structured method with

x_{i}

guards is the only human-scalable design (see Truth Tables and Minterms).

If the MSBs of

A

and

B

differ, the lower bits have no effect on the result.

True. The highest differing bit decides everything, exactly like the first differing digit when you compare

3746

3752

. Lower bits are irrelevant once a higher bit breaks the tie.

The expression

G = A_{1} \overset{ˉ}{B}_{1} + A_{0} \overset{ˉ}{B}_{0}

correctly computes greater-than for a 2-bit comparator.

False. The LSB term is missing its guard: it must be

x_{1} A_{0} \overset{ˉ}{B}_{0}

, otherwise the LSB "votes greater" even when the MSB already decided

A < B

XNOR and "equal" mean the same thing at the single-bit level.

True. For one bit,

A = B

is exactly

\overline{A \oplus B}

; that is why the whole equality output is a product of XNOR terms

E = x_{n - 1} \dots x_{0}

(see XOR and XNOR Gates).

A comparator needs a clock to work.

False. It is a combinational circuit: outputs depend only on the current inputs, no memory or clock — that is the whole point of doing it with pure gates.

Spot the error

E = x_{1} + x_{0}

— equality means at least one bit matches."

Error: wrong operator. Equality needs every bit to match, so it is an AND (product):

E = x_{1} x_{0}

. Using OR would report "equal" whenever a single bit happened to agree.

L = \overset{ˉ}{A}_{1} B_{1} + \overset{ˉ}{A}_{0} B_{0}

for a 2-bit comparator."

Error: unguarded LSB term. The correct form is

L = \overset{ˉ}{A}_{1} B_{1} + x_{1} \overset{ˉ}{A}_{0} B_{0}

. Without the

x_{1}

guard the LSB term can fire even when the MSB already made

A > B

, giving two contradictory outputs high at once.

"Comparators work LSB-first, just like a Ripple Carry Adder."

Error: wrong scan direction. Adders propagate a carry LSB→MSB, but magnitude is dominated by the MSB, so comparators must decide MSB-first. Copying the adder's direction breaks the logic.

"For a 1-bit comparator,

G = A \overset{ˉ}{B}

and

L = A \overset{ˉ}{B}

by symmetry."

Error: $L$ is the mirror, not the copy.

G = A \overset{ˉ}{B}

(only

A = 1, B = 0

), and

L = \overset{ˉ}{A} B

(only

A = 0, B = 1

). Swapping which variable is inverted is the whole difference between greater and less.

"In a cascaded 7485, feed the local decision through as

(A > B)_{o u t} = G_{l oc a l} \cdot E_{l oc a l} (A > B)_{in}

Error: should be OR, not AND. The correct rule is

(A > B)_{o u t} = G_{l oc a l} + E_{l oc a l} (A > B)_{in}

: either the local bits already decided (

G_{l oc a l}

), or they tied (

E_{l oc a l}

) and we trust the cascade input.

"To chain two 7485 IC chips for 8 bits, wire the high nibble's outputs into the low nibble's cascade inputs."

Error: direction reversed. The less-significant chip's outputs feed the more-significant chip's cascade inputs, because the high chip decides first and only defers downward when its own bits tie.

G + E + L

can equal

0

if the two numbers are unrelated."

Error: never zero. Any two unsigned numbers are always one of

>

=

<

— there is no "unrelated" case, so the sum is always exactly

1

Why questions

Why is equality built from XNOR rather than XOR?

Because XOR marks where bits differ; equality is the absence of any difference, which is the negation of XOR, i.e. XNOR — "eXactly No difference".

Why must every lower-bit decision term carry an

x_{i}

prefix?

The prefix says "all higher bits were equal, so this is the first differing bit". Without it, a lower bit could override a higher bit that already decided the comparison, violating the MSB-first rule.

Why do we compare from the MSB downward instead of the LSB upward?

Because a single higher-order bit outweighs all lower bits combined (

2^{k} > 2^{k - 1} + \dots + 2^{0}

), so the first place the numbers differ, reading from the top, settles the magnitude.

Why does the 7485 provide cascade inputs at all?

So several 4-bit chips can be chained into wider comparators: when a chip's own four bits all tie (

E_{l oc a l} = 1

), it passes the decision made by a less-significant chip through, extending the first-differing-bit rule across chip boundaries.

Why tie the least-significant chip's

(A = B)_{in}

1

in a cascade?

So that if every bit across all chips matches, the equality signal propagates cleanly to the top output and reports "equal" — the base case of the chain has nothing below it to defer to.

Why can subtraction be used as an alternative comparator?

Computing

A - B

and inspecting the sign/borrow tells you which is larger (see Binary Subtraction); a negative result means

A < B

, zero means equal. It answers the same question by a different route.

Why is a comparator grouped with blocks like Multiplexers?

Both are combinational decision-makers: outputs are a pure function of current inputs with no stored state, computing a choice instantly from logic gates alone.

Edge cases

What do the outputs read when

A = B = 0000

All four

x_{i} = 1

, so

E = x_{3} x_{2} x_{1} x_{0} = 1

while

G = L = 0

. Zero equals zero — the equality path fires exactly as for any other tie.

What happens if only the LSB differs, e.g.

A = 0110

B = 0111

The three higher bits tie (

x_{3} x_{2} x_{1} = 1

) and the LSB decides:

A_{0} = 0, B_{0} = 1

gives

L = 1

. The guarded LSB term is the one and only active term.

What happens if only the MSB differs, e.g.

A = 1000

B = 0111

The MSB decides immediately:

A_{3} \overset{ˉ}{B}_{3} = 1

gives

G = 1

, and every lower term is killed because it requires

x_{3} = 1

(but the MSBs differ, so

x_{3} = 0

). Lower bits are silenced.

In the 2-bit case, can both

x_{1} = 1

and

A_{1} \overset{ˉ}{B}_{1} = 1

happen together?

No.

x_{1} = \overline{A_{1} \oplus B_{1}}

means the MSBs match, while

A_{1} \overset{ˉ}{B}_{1}

requires

A_{1} = 1, B_{1} = 0

(they differ). They are mutually exclusive, which is why no two of

G, E, L

ever fire at once.

For a single 4-bit 7485 used alone (not cascaded), how should the cascade inputs be set?

Set

(A = B)_{in} = 1

and

(A > B)_{in} = (A < B)_{in} = 0

, so that when all four bits tie the chip reports "equal" rather than an undefined pass-through.

What if two numbers have different bit-widths, say compare

3

-bit

A

with

5

-bit

B

Zero-extend the shorter number to the same width first (

A \to 00 A

). Comparing mismatched widths directly is meaningless; the MSB positions must line up by place value.

Recall One-line self-test

XOR vs equality? → XOR = differ, so equality is XNOR.
Missing $x_{i}$ guard causes? → contradictory outputs, lower bit overrides higher.
Scan direction? → MSB-first, first differing bit wins.
$E_{l oc a l} = 1$ in a 7485 means? → local bits tied, defer to cascade input.
$G + E + L$ ? → always exactly $1$ .

Connections

Comparators — parent topic this bank drills.
XOR and XNOR Gates — the equality primitive the traps revolve around.
Truth Tables and Minterms — why the giant-table approach fails at scale.
Binary Subtraction — the sign-of-difference alternative.
Ripple Carry Adder — contrast: LSB-first vs comparator's MSB-first.
7485 IC — the cascade rules probed in the edge cases.