6.3 Full Adder: Adding Two Bits Plus an Incoming Carry
Derive the full adder's SUM and Cout equations for three inputs (A, B, Cin), verify them against a full 8-row truth table, and explain how full adders chain together to add multi-bit binary numbers correctly.
The full adder extends the half adder by adding a third input, Cin (carry-in), so it can correctly add two bits together with a carry arriving from a less-significant bit position — exactly the capability the half adder lacks. Because a full adder can absorb an incoming carry, chaining a sequence of full adders together (one per bit position, with each stage's carry-out wired to the next stage's carry-in) is the standard way to build an adder for binary numbers of any width, making the full adder the single most important combinational arithmetic building block in this module.
Deriving SUM from three inputs
With three inputs (A, B, Cin), there are 8 possible input combinations to consider. SUM must represent the least-significant bit of A+B+Cin, which turns out to be 1 whenever an odd number of the three inputs are 1 (one input is 1, or all three are 1) and 0 whenever an even number are 1 (zero or two inputs are 1). This 'odd number of 1s' pattern is exactly what a chain of XOR operations computes, giving the compact equation SUM = A ⊕ B ⊕ Cin.
This is a direct three-input generalization of the half adder's SUM = A ⊕ B: XOR is associative and commutative, so A ⊕ B ⊕ Cin can be computed with two 2-input XOR gates in sequence (first A ⊕ B, then that result XOR Cin) without any loss of correctness or need for a dedicated 3-input XOR gate.
Deriving Cout from three inputs
Cout (carry-out) must be 1 whenever at least two of the three inputs are 1 — because two or more 1-bits among A, B, and Cin sum to at least 2, which requires a carry into the next bit position. Listing every pair of inputs that could both be 1 and OR-ing the corresponding AND terms together gives Cout = AB + ACin + BCin: the term AB catches the case where A and B are both 1 (regardless of Cin), ACin catches A and Cin both 1, and BCin catches B and Cin both 1.
This equation can equivalently be derived via a K-map on the 8-row truth table (an application of the 3-variable K-map technique from Module 5): the four minterms where Cout=1 are exactly the four combinations with two or three 1-bits among A, B, Cin, and grouping them on a 3-variable map yields precisely the three 2-literal terms AB, ACin, and BCin, with no further reduction possible.
Chaining full adders for multi-bit addition
Because each full adder stage accepts a Cin and produces a Cout, a sequence of full adders can be connected so that bit position i's Cout feeds directly into bit position i+1's Cin. The least-significant bit position typically uses either a half adder (since there is no carry to receive there) or a full adder with Cin hard-wired to 0, and every higher bit position uses a full adder proper. This chained structure — explored in depth as the ripple-carry (parallel) adder later in this module — is what makes it possible to add binary numbers of arbitrary width using only 1-bit adder cells replicated across each bit position.
Full adder equations
3 inputs (A, B, Cin) and 2 outputs (SUM, Cout). SUM is 1 for an odd count of 1-inputs; Cout is 1 for two or more 1-inputs among the three.
SUM = A ⊕ B ⊕ Cin
Cout = AB + ACin + BCinCode Examples
Scanning the SUM column confirms it is 1 on exactly the four rows with an odd number of 1-inputs (one or three 1s among A,B,Cin), matching SUM = A⊕B⊕Cin. Scanning the Cout column confirms it is 1 on exactly the four rows with two or more 1-inputs, matching Cout = AB + ACin + BCin.
SUM tracks an odd count of 1-inputs; Cout tracks two-or-more 1-inputs among A, B, Cin.
This is the spec's own worked example: three 1s produce binary 11 — sum bit 1, carry bit 1. Adding all three input bits directly gives 1+1+1=3, and 3 in binary is '11', which matches reading Cout and SUM together as a 2-bit result (Cout as the higher bit, SUM as the lower bit). Expected result: SUM=1, Cout=1
A=1, B=1, Cin=1 → SUM=1, Cout=1, matching 1+1+1=3=binary 11.
A B Cin | SUM Cout
0 0 0 | 0 0
0 0 1 | 1 0
0 1 0 | 1 0
0 1 1 | 0 1
1 0 0 | 1 0
1 0 1 | 0 1
1 1 0 | 0 1
1 1 1 | 1 1
Check SUM row A=1,B=1,Cin=1: three 1-inputs (odd count) -> SUM=1. Matches.
Check Cout row A=0,B=1,Cin=1: two 1-inputs (B and Cin) -> Cout=1 via the BCin term. Matches.A=1, B=1, Cin=1
SUM = A XOR B XOR Cin = 1 XOR 1 XOR 1 = 1
Cout = AB + ACin + BCin = (1)(1) + (1)(1) + (1)(1) = 1 + 1 + 1 = 1
Result: SUM=1, Cout=1 --> 1+1+1 = 3 = binary "11" (Cout,SUM)Full adder block diagram
A full adder takes three inputs (including a carry-in) and produces SUM and a carry-out that can feed the next stage.
A B Cin
| | |
+---+----+---> [ SUM = A XOR B XOR Cin ] (two 2-input XOR gates in series)
| | |
+---+----+---> [ Cout = AB + ACin + BCin ] (three AND gates + one 3-input OR gate)
Inputs: A, B, Cin Outputs: SUM, Cout
Cout of one stage wires directly into Cin of the next stage in a multi-bit chain.Important Rules
SUM = A ⊕ B ⊕ Cin — computable with two chained 2-input XOR gates.
Cout = AB + ACin + BCin — 1 whenever at least two of the three inputs are 1.
A full adder's Cout output connects to the next-higher bit position's Cin input when chaining adders for multi-bit addition.
The least-significant bit of a multi-bit adder can use a half adder or a full adder with Cin tied to 0; every other bit position needs a true full adder.
The full adder as the atomic arithmetic cell
The full adder is the single most replicated arithmetic cell in real digital hardware: every ALU in every CPU contains dozens to hundreds of full-adder-equivalent cells (directly, in a ripple-carry or carry-look-ahead adder, or indirectly, inside multiplier and divider circuits that reduce to repeated addition). Because it is used so pervasively, real silicon implementations are usually built from more transistor-efficient gate-level circuits than a literal 'two XORs plus three ANDs plus an OR' schematic, but the Boolean equations SUM = A⊕B⊕Cin and Cout = AB+ACin+BCin remain the specification every one of those optimized implementations must satisfy.
How It's Built From Other Gates
(A XOR B), Cin Full adder SUM path: SUM = A XOR B XOR Cin, built from two 2-input XOR gates in sequence rather than one 3-input XOR gate.
How It's Built From Other Gates
AB, ACin, BCin Full adder Cout path: Cout = AB + ACin + BCin — three parallel AND gates covering every pair that can both be 1, OR'd together.
Computing SUM as simply A ⊕ B and ignoring Cin, treating a full adder like a half adder with an extra unused pin.
Include Cin in the XOR chain: SUM = A ⊕ B ⊕ Cin, since the incoming carry directly affects whether the current bit's sum is 0 or 1.
Dropping Cin from the SUM computation defeats the entire purpose of the full adder — it is precisely the ability to fold in a carry-in that distinguishes it from a half adder.
Assuming three 1-inputs (A=1,B=1,Cin=1) produce Cout=0 because 'all three being the same' seems like a special, carry-free case.
Recognize that 1+1+1=3, which in binary is '11' — two bits are needed, so both SUM and Cout must be 1.
The spec's tricky problem states this directly: three 1s produce binary 11, sum bit 1, carry bit 1. Cout depends on the total count of 1-inputs being two or more, and three certainly satisfies that.
[tricky] For a full adder with A=1, B=1, and Cin=1, what are SUM and Cout, and what does this represent in binary? A. SUM=1, Cout=1, representing binary 11 (decimal 3), since 1+1+1=3 B. SUM=0, Cout=1, representing binary 10 (decimal 2) C. SUM=1, Cout=0, representing binary 01 (decimal 1) D. SUM=0, Cout=0, representing binary 00 (decimal 0)
A. SUM=1, Cout=1, representing binary 11 (decimal 3), since 1+1+1=3 — The spec's tricky problem states this directly: three 1s produce binary 11 — sum bit 1, carry bit 1. Adding all three inputs gives 1+1+1=3, and binary 11 (Cout=1, SUM=1) correctly represents decimal 3.
What is the correct Boolean equation for a full adder's carry-out, Cout? A. Cout = AB + ACin + BCin B. Cout = A + B + Cin C. Cout = A ⊕ B ⊕ Cin D. Cout = ABCin (AND of all three inputs)
A. Cout = AB + ACin + BCin — Cout must be 1 whenever at least two of the three inputs are 1. Cout = AB + ACin + BCin correctly captures exactly this: each term is 1 when a particular pair of inputs is both 1, and the OR combines all three pairwise cases. A ⊕ B ⊕ Cin is the SUM equation, not Cout, and ABCin alone (a pure AND) would miss the cases where exactly two inputs are 1.
Why does a full adder use two 2-input XOR gates in series rather than a single 3-input XOR gate for SUM? A. Because XOR is associative, A ⊕ B ⊕ Cin can be computed correctly as (A ⊕ B) ⊕ Cin using two 2-input XOR gates, which is the standard implementation approach B. Because 3-input XOR gates do not exist in Boolean algebra C. Because using two gates always produces a different (incorrect) result than a single 3-input gate would D. Because Cin must be processed by a separate, dedicated gate type
A. Because XOR is associative, A ⊕ B ⊕ Cin can be computed correctly as (A ⊕ B) ⊕ Cin using two 2-input XOR gates, which is the standard implementation approach — XOR's associativity means grouping the operands differently — (A ⊕ B) ⊕ Cin versus A ⊕ (B ⊕ Cin) — always produces the identical result, so a full adder's SUM can be built from two ordinary 2-input XOR gates chained together, which is the conventional gate-level implementation.
Using the full adder equations, compute SUM and Cout for A=0, B=1, Cin=1, and verify your answer represents 0+1+1=2 correctly in binary.
Two of the three inputs (B and Cin) are 1. SUM = 0⊕1⊕1 = 0 (even count of 1s). Cout = (0)(1) + (0)(1) + (1)(1) = 0+0+1 = 1. Result: SUM=0, Cout=1, giving Cout,SUM = '10' in binary, which is decimal 2 — matching 0+1+1=2.
Count how many of the three inputs are 1, then apply the odd-count rule for SUM and the two-or-more rule for Cout.