1

I have a little confusion regarding the Don't care condition in the karnaugh map. As we all know karnaugh map is used to achieve the

  1. complete
  2. accurate/precise
  3. optimal

output equation of 16bit or sometime 32 bits binary solution,till that everything was alright but the problem arises when we insert a dont care conditions in it. My question was that, As even the dont care conditions were generated from the o's or 1's solution of truth table & in karnaugh map we sometimes conclude or sometimes ignore dont care conditions in our karnaugh map groups. so is it an ambiguity in a karnaugh map that we ignore dont care conditions in the karnaugh map beacuse we dont know what is behind that dont care condition is it 1 or 0. so afterwards that how could we confidently use to say that our solution is complete or accurate while we are ignoring the dont care conditions in it. May be the dont care we are ignoring contains a 1 in sop and 0 at pos so according to it may contain an error.

Ahmad Raza
  • 145
  • 6

2 Answers2

1

A "don't care" is just that. Something that we don't care about. It gives us an opportunity for additional optimization, because that value is not restricted. We are able to make it whatever we wish in order to achieve the most optimal solution.

Because we don't care about it, it doesn't matter what the value is. We will use whatever suits us best (lowest cost, fastest, etc... "optimal"). If it's better as a 1 in one implementation and a 0 in another, so be it, it doesn't matter.

Yes there is always another case with the don't care, but we can say it's complete/accurate because we don't care about the other one. We will treat it whichever way makes our implementation better.

jsarbour
  • 928
  • 1
  • 8
  • 20
  • 1
    if we dont care about those conditions then why would we use it while grouping, all those dont care conditions should need to be remained ungrouped.b/c we dont care about them right?? – Ahmad Raza May 23 '19 at 18:43
  • 1
    Because we *can*. We don't care if it's a one or a zero, so we can choose to force it to a one should we decide it is more useful to. – jsarbour May 23 '19 at 18:47
0

Let's take a very simple example to understand what "don't care conditions" exactly mean.

Let F be a two-variable Boolean function defined by a user as follows:

A  B    F

0  0    1
0  1    0

This function is not defined when the value of A is 1.

This can mean one of two things :-

  1. The user doesn't care about the value that F produces when A = 1.
  2. The user guarantees that A = 1 will never be given as an input to F.

Both of these cases are collectively known as "don't care conditions".

Now, the person implementing this function can use this fact to their advantage by extending the definition of F to include the cases when A = 1.

Using a K-Map,

     B'  B
A' | 1 | 0 |
A  | X | X |

Without these don't care conditions, the algebraic expression of F would be written as A'B', i.e. F = A'B'.

But, if we modify this map as follows,

     B'  B
A' | 1 | 0 |
A  | 1 | 0 |

then F can be expressed as F = B'.

By modifying this map, we have basically extended the definition of F as follows:

A  B    F

0  0    1
0  1    0
1  0    1
1  1    0

This method works because the person implementing the function already knows that either the user will not care what happens when A = 1, or the user will never use A = 1 as an input to F.

Another example is a four-variable Boolean function in which each of those 4 variables denotes one distinct bit of a BCD value, and the function gives the output as 1 if the equivalent decimal number is even & 0 if it is odd. Here, since it is guaranteed that the input will never be one of 1010, 1011, 1100, 1101, 1110 & 1111, therefore the person implementing the function can extend the definition of the function to their advantage by including these cases as well.

Kushagr Jaiswal
  • 191
  • 1
  • 9