Don't-Care Conditions

Introduction to Don't-Care Conditions

Don't-care conditions occur when:

• Certain input combinations never occur
• The output for certain inputs doesn't matter
• We can choose output to be 0 or 1 for optimization

Notation: Often marked as X or d in truth tables and K-maps

Example: A BCD decoder only uses values 0-9 (0000-1001).

Inputs 10-15 (1010-1111) are "don't cares" - they never happen, so we can assign them 0 or 1 to help simplify.

Don't-Cares in K-maps

Using don't-cares in K-maps:

1. Mark don't-cares with X in the K-map
2. When forming groups, treat X as 1 if it helps make larger groups
3. X can be included in groups OR left out - your choice
4. Don't-cares don't need to be covered - they're optional

Key rule: Use don't-cares to make groups larger, but you don't HAVE to use them.

Example: If including an X lets you make a group of 4 instead of 2, include it!

Don't-Care Examples

Common sources of don't-cares:

1. Invalid input combinations

   • BCD codes (only 0-9 valid out of 0-15)
   • Gray code transitions
   • One-hot encodings

2. Output doesn't matter

   • Display off $\to$ segment values irrelevant
   • Error state $\to$ specific output unimportant

3. Timing/sequence constraints

   • Some states are unreachable
   • Certain transitions can't happen

Exploiting don't-cares can significantly reduce circuit complexity.

Don't-Care Notation

Don't-care notation in function specification:

Sum of minterms with don't-cares: f(A,B,C) = $\Sigma$m(1,2,5) + d(3,7)

This means:

• Function is 1 at minterms 1, 2, 5
• Function is 0 at minterms 0, 4, 6
• Minterms 3 and 7 are don't-cares

Product of maxterms with don't-cares: f(A,B,C) = $\Pi$M(0,4,6) · d(3,7)

Both notations describe the same function with same don't-cares.

Don't-Care Strategy

Strategy for using don't-cares:

1. Mark don't-cares as X on the K-map
2. Find prime implicants treating X as potential 1s
3. Only include X if it enlarges a group
4. Don't cover isolated X - they become 0

Key insight: You're "spending" don't-cares as 1s to buy larger groups.

Unused don't-cares default to 0.

Multiple outputs: When a circuit has several outputs, don't-cares can be assigned differently for each output to optimize each one!

Don't-Care Practice

Remember the don't-care rules:

• Don't-cares (X) can be 0 or 1 - your choice
• Include X only to enlarge groups
• Don't-cares don't need to be covered
• Unused don't-cares become 0 in the final function
• Goal: minimize expression while covering all 1s

When Don't-Cares Arise

Don't-cares arise when:

1. Impossible input combinations - e.g., BCD: 1010-1111 never occur
2. Output doesn't matter - certain states are never observed
3. Incompletely specified functions - designer hasn't decided yet
4. Redundant inputs - some combinations are physically impossible

Key insight: Don't-cares represent freedom in the design!

We can assign them 0 or 1 to get simpler circuits.

Strategy for Using Don't-Cares

Strategy for don't-cares:

1. Mark don't-cares with X on the K-map
2. Treat X as 1 when it enlarges a group covering real 1s
3. Leave X as 0 when it doesn't help grouping
4. Never require X to be covered - they're optional
5. Different Xs can be treated differently

Goal: Use don't-cares to maximize group sizes!

K-maps with Don't-Cares Expanded

Don't-care examples:

F = $\Sigma$m(1,3) + d(0,2)    2-var K-map:
     B=0  B=1
A=0 [ X    1 ]   $\leftarrow$ d(0), m(1)
A=1 [ X    1 ]   $\leftarrow$ d(2), m(3)

Simplification: $m_1$ and $m_3$ form column B=1.

We could group all 4 cells (treating don't-cares as 1), giving the constant function 1. But a simpler solution uses just the B=1 column $\to$ B.

Optimal Don't-Care Usage Challenge

Optimal don't-care usage:

Sometimes there are multiple ways to use don't-cares:

• Different Xs might enlarge different groups
• You might need to choose which group to enlarge
• Goal: minimum number of terms AND minimum literals

Strategy: Try different combinations, compare results.

Real-World Don't-Cares - BCD

BCD (Binary Coded Decimal):

Uses 4 bits to represent decimal digits 0-9:

• 0000 $\to$ 0, 0001 $\to$ 1, ..., 1001 $\to$ 9
• 1010 through 1111 are invalid (don't-cares!)

Example: Design a circuit to detect digits > 4.

• Output 1 for: 5(0101), 6(0110), 7(0111), 8(1000), 9(1001)
• Output 0 for: 0-4
• Don't care for: 10-15 (never occur in valid BCD)

Simplification Synthesis

Simplification Summary:

Full simplification toolkit:

1. Algebraic laws (identity, complement, absorption, etc.)
2. K-maps for visual grouping
3. Don't-cares for practical optimization
4. Verification by truth table

Simplification Challenge

This challenge integrates all Simplification concepts:

• Algebraic laws and strategies
• K-map grouping and optimization
• Don't-care usage
• Choosing between methods
• Verification techniques