Don't Care Conditions
A don't care (written X or d or φ) is an input combination for which the output value is irrelevant — either because that input can never occur, or because nothing downstream looks at the output for that input.
Notation: F(A,B,C,D) = Σm(1, 3, 7) + d(0, 5)
F(A,B,C,D) = ΠM(2, 4, 6) . d(0, 5)Why Don't Cares Exist
| Situation | Example |
|---|---|
| Invalid input codes | BCD uses 0000–1001; the codes 1010–1111 can never appear |
| Unused states | A counter designed for 6 states leaves 2 of 8 combinations unused |
| Output ignored downstream | An error output that is only sampled when a valid flag is high |
| Mutually exclusive inputs | Two sensors that physically cannot both be active |
The Rule
Treat each X as whatever helps you. Include an X in a group if doing so makes the group larger; ignore it otherwise. You never have to cover an X.
X included in a group -> you have decided that output = 1 there (for SOP)
X left uncovered -> you have decided that output = 0 there
Either decision is legal, because the input never occurs.Worked Example 1 — 4 Variables
F(A, B, C, D) = Σm(1, 3, 7, 11, 15) + d(0, 2, 5)
CD
00 01 11 10
+------+------+------+------+
AB 00 | X | 1 | 1 | X |
| (0) | (1) | (3) | (2) |
+------+------+------+------+
01 | 0 | X | 1 | 0 |
| (4) | (5) | (7) | (6) |
+------+------+------+------+
11 | 0 | 0 | 1 | 0 |
| (12) | (13) | (15) | (14) |
+------+------+------+------+
10 | 0 | 0 | 1 | 0 |
| (8) | (9) | (11) | (10) |
+------+------+------+------+Without don't cares (treat every X as 0)
Group 1: m3, m7, m11, m15 (column CD = 11) -> CD
Group 2: m1, m3 (row AB=00) -> A'B'D
F = CD + A'B'D (2 terms, 5 literals)With don't cares used intelligently
Group 1: m3, m7, m11, m15 (column CD = 11) -> CD
Group 2: m1, m3, d5, m7 (columns CD=01 and CD=11, rows AB=00 and AB=01)
A = 0 constant -> A'
B changes -> drop
C changes -> drop
D = 1 constant -> D
-> A'D
F = CD + A'D (2 terms, 4 literals) <- one literal cheaperNote that d0 and d2 were left uncovered — including them would have forced a group containing 0-cells, which is illegal. Don't cares are an option, never an obligation.
Worked Example 2 — BCD "Greater than 4" Detector
Design a circuit whose output is 1 when a BCD digit (0–9) is greater than 4. Inputs A B C D with A as MSB.
Valid inputs: 0000 (0) ... 1001 (9)
Output = 1 for 5, 6, 7, 8, 9 -> Σm(5,6,7,8,9)
Invalid inputs 10-15 -> d(10,11,12,13,14,15)
CD
00 01 11 10
+------+------+------+------+
AB 00 | 0 | 0 | 0 | 0 |
01 | 0 | 1 | 1 | 1 |
11 | X | X | X | X |
10 | 1 | 1 | X | X |
+------+------+------+------+
Group 1 (8 cells): rows AB=11 and AB=10, all four columns
-> m8, m9, d10, d11, d12, d13, d14, d15
A = 1 constant, B/C/D change -> A
Group 2 (4 cells): m5, m7, d13, d15 (columns CD=01, CD=11; rows AB=01, AB=11)
B = 1, D = 1 constant -> BD
Group 3 (4 cells): m6, m7, d14, d15 (columns CD=11, CD=10; rows AB=01, AB=11)
B = 1, C = 1 constant -> BC
F = A + BD + BC (3 terms, 5 literals)Without don't cares the same function needs F = AB'C' + A'BC + A'BD — noticeably more hardware. This is the classic exam demonstration of why don't cares matter.
Worked Example 3 — POS with Don't Cares
F(A, B, C, D) = ΠM(0, 1, 2, 4, 8) · d(3, 5, 10)
The 0s are at m0, m1, m2, m4, m8; X at m3, m5, m10; the rest are 1s.
CD
00 01 11 10
+------+------+------+------+
AB 00 | 0 | 0 | X | 0 |
01 | 0 | X | 1 | 1 |
11 | 1 | 1 | 1 | 1 |
10 | 0 | 1 | 1 | X |
+------+------+------+------+
Group the ZEROS (X may join if useful):
Group 1 (4): m0, m1, m4, m5(X) -> A = 0 -> A ; C = 0 -> C -> (A + C)
Group 2 (4): m0, m2, m8, m10(X) -> four corners: B = 0 -> B ; D = 0 -> D -> (B + D)
All real zeros covered? m0 ✓ m1 ✓ m2 ✓ m4 ✓ m8 ✓
F = (A + C)(B + D)Don't Cares in Digit Displays — the classic application
A 7-segment decoder takes a BCD input and drives seven segments. Inputs 1010–1111 never occur in BCD, giving six free don't cares on every one of the seven output functions — which is why a 7447 decoder IC is far smaller than the naive design.
Segment 'a' (top bar) is ON for digits 0, 2, 3, 5, 6, 7, 8, 9
a = Σm(0, 2, 3, 5, 6, 7, 8, 9) + d(10..15)
K-map with don't cares gives: a = A + C + BD + B'D'
Without don't cares it needs six product terms.Summary
| Point | Detail |
|---|---|
| Symbol | X, d or φ in the K-map cell |
| Notation | Σm(...) + d(...) or ΠM(...) · d(...) |
| SOP use | Include an X only if it enlarges a 1-group |
| POS use | Include an X only if it enlarges a 0-group |
| Obligation | None — X cells never have to be covered |
| Benefit | Fewer literals, fewer gates, lower cost and delay |
| Risk | If the "impossible" input does occur, the output is whatever your grouping implied — document it |
Practice
1. F(A,B,C) = Σm(1, 3, 7) + d(0, 5)
1s: m1, m3, m7; X: m0, m5
Group m1, m3, m5(X), m7 -> column pattern C=1 across ... check: m1=001, m3=011,
m5=101, m7=111 -> C = 1 in all four, A and B change
F = C
2. F(A,B,C,D) = Σm(0, 1, 2, 8, 9, 10) + d(3, 11)
Group m0,m1,m2,m3(X),m8,m9,m10,m11(X) -> B = 0 in all eight
F = B'
3. F(A,B,C,D) = ΠM(1, 3, 5, 7, 9, 11) . d(13, 15)
Zeros at odd minterms 1..11, X at 13, 15 -> group all D=1 cells
F = (D')Unit I's simplification toolkit is now complete. The remaining Unit I lessons build the first useful circuits from these gates: adders and subtractors.