Full Subtractor

A Full Subtractor extends the Half Subtractor by accepting a third input — the Borrow-in (Bin) — from the previous bit position. It produces a Difference output and a Borrow-out, enabling cascaded multi-bit binary subtraction. It is analogous to the Full Adder in structure and is equally important for GATE combinational circuit questions.

Core Concept Explanation

In multi-bit binary subtraction, each bit position may receive a borrow from the bit position to its right (less significant side). The Full Subtractor handles this by accepting Borrow-in (Bin) as an input alongside the two operand bits A and B. It computes A minus B minus Bin and delivers the result as a Difference bit D and a Borrow-out (Bout) to the next higher bit position.

The Full Subtractor can be built using two Half Subtractors and one OR gate. The first Half Subtractor computes D1 = A XOR B and Bout1 = A' AND B. The second Half Subtractor then computes D = D1 XOR Bin and Bout2 = D1' AND Bin. The final Borrow-out is Bout = Bout1 OR Bout2. This two-level cascade is structurally identical to how a Full Adder uses two Half Adders.

The Full Subtractor truth table has 8 rows (3 inputs). Borrow-out is 1 in any row where the value being subtracted (B + Bin) exceeds A. A borrow propagates when the current bit cannot absorb the subtraction from available resources.

Mathematical Expression

The Boolean equations for Full Subtractor outputs, derived via Karnaugh map or truth table:

• Difference: D = A XOR B XOR Bin
• Borrow-out: Bout = A'B + A'Bin + B.Bin

The Difference expression is identical in form to the Sum expression of a Full Adder (A XOR B XOR Cin). The Borrow-out expression differs from the Carry-out of a Full Adder. The Borrow-out is 1 when at least two of the three conditions hold: A=0 with B=1, A=0 with Bin=1, or B=1 and Bin=1. Each term in the Bout expression represents a scenario where the subtracted value exceeds the minuend bit.

Practical Understanding

For n-bit binary subtraction, n Full Subtractors are cascaded with the Borrow-out of each stage feeding the Borrow-in of the next more significant stage, analogous to the Ripple Carry Adder. The Borrow-in of the LSB stage is set to 0 for pure subtraction.

In practice, dedicated subtractor circuits are less common in processor ALUs. Instead, subtraction is performed using 2s complement: the subtrahend is bitwise-inverted and 1 is added (by setting Cin=1 in the adder). This reuses the adder hardware and eliminates the need for separate subtractor logic. Nevertheless, the Full Subtractor is a core concept in combinational circuit analysis for examinations.

Given:
A = 1, B = 0, Bin = 1 (subtracting B and Borrow-in from A)

Why this formula applies:
Full Subtractor handles 3-input single-bit subtraction including incoming borrow.

Formula:
D = A XOR B XOR Bin
Bout = A'B + A'Bin + B.Bin

Substitution:
D = 1 XOR 0 XOR 1 = 0
A' = 0
Bout = (0)(0) + (0)(1) + (0)(1) = 0 + 0 + 0 = 0

Calculation:
D = 0 (difference bit)
Bout = 0 (no borrow out required)

Final Answer: D = 0, Bout = 0 — 1 - 0 - 1 = 0 exactly, no borrow propagated to next bit position

Exam Tip: The Difference equation D = A XOR B XOR Bin is identical to Full Adder Sum = A XOR B XOR Cin. However, Bout = A'B + A'Bin + BBin is NOT the same as Full Adder Carry = AB + ACin + BCin. The borrow uses A' terms while carry uses A. This distinction is a common GATE trap.

Quick Revision

• Full Subtractor has three inputs (A, B, Bin) and two outputs (D, Bout).
• Difference: D = A XOR B XOR Bin — same XOR structure as Full Adder sum.
• Borrow-out: Bout = A'B + A'Bin + B.Bin — note A' terms, unlike Full Adder carry.
• Implementation: two Half Subtractors + one OR gate (parallel to Full Adder structure).
• Multi-bit subtractor: cascade Full Subtractors with Bout of stage i feeding Bin of stage i+1.
• Exam trap: Bout uses A' (NOT A), while Full Adder Cout uses A directly — do not swap them.
• In practice, 2s complement addition replaces subtractor hardware in ALU design.