K-Map Solver
Home/Examples/Full Adder
Arithmetic Logic · Two outputs, two very different results

Full Adder: Sum and Carry-Out

A full adder takes three inputs — two bits to add (A, B) and a carry-in (Cin) — and produces two outputs: Sum and Carry-out. Minimizing both side by side makes a point worth remembering: two outputs sharing the exact same inputs can behave completely differently under grouping.

The truth table

ABCinSumCout
00000
00110
01010
01101
10010
10101
11001
11111

Sum: no simplification available

Sum is 1 whenever an odd number of the three inputs are 1 — that's exactly a 3-input XOR, the same structure covered in full in the parity checker example. Minimized, it comes out to four full 3-literal terms — no grouping possible at all, for exactly the same structural reason: the required 1s form a checkerboard pattern with no two adjacent.

Sum = A′B′Cin + A′BCin′ + AB′Cin′ + ABCin

Carry-out: simplifies cleanly

Carry-out is 1 whenever at least two of the three inputs are 1 — this is the majority function, also covered from the truth-table side in From Truth Table to Minimal Expression. Unlike Sum, this one groups into three clean 2-literal pairs, all essential:

Cout = BCin + ACin + AB

Same three inputs, same map size, completely different outcome — Sum is the worst case for K-map grouping, Cout is a clean case, and there's no way to know which you'll get without actually working through the map for each output separately.

Try Carry-out live

The solver below is pre-loaded with Cout's truth table.

Input
Karnaugh Map
Minimal Result
Output format
F = 0
Prime Implicant Analysis
Auto-generated Circuit
Universal Gate Conversion

Frequently asked questions

Why is Cout called the "majority function"?

Because it outputs 1 exactly when the majority (2 or more) of its three inputs are 1 — the same logic as a 3-way vote. It shows up under that name in voting and redundancy-checking circuits too, not just adders.

Is there a way to make Sum simplify too?

Not through K-map grouping — see the parity checker example for why XOR-structured functions are structurally resistant to this. In practice, Sum is built directly from XOR gates rather than minimized as AND-OR logic.

Does a 4-bit (or wider) adder change any of this?

No — a multi-bit adder is just this same full-adder logic repeated per bit, with each stage's Cout feeding the next stage's Cin. Sum and Cout keep exactly the same structure at every stage.