Karnaugh maps are a formalized way of turning a truth table into a fairly minimal logical expression.
It’s fairly minimal in that it’s the minimal “sum of products” representation, but that might not be the minimal representation of the logic circuit.
The sum of products representation just means that you OR (sum) multiple terms that are ANDed (product) together. For instance the below is a sum of products expression:
With multiplication being AND, addition being OR, and a line over a letter being a NOT, the above could be written in C++ code like this:
bool out = (!A && B) || (A && B);
It would be real easy to write code like that especially if you were adding onto an existing condition, and you might not even notice that it isn’t the minimal Boolean expression to make the desired output.
Using Boolean algebra, you can do the following simplifications:
Which simplifies the C++ code to just this:
bool out = B;
Using Boolean algebra to simplify, you’d have to remember (or derive) the identity that , and all the other identities to help you simplify equations.
Karnaugh maps make this easier because you will be able to see visually what can be combined (simplified) and what can’t.
Again though, while they give you the smallest possible sum of products representation of the logic circuit, that may not be the smallest possible representation of the circuit.
Let’s get to it!
Two Variable Karnaugh Map: Basics
Going with the example above, it takes two Boolean variables as input (A and B), and gives one Boolean variable as output. Having two input variables means we need a two variable Karnaugh map.
The first step to building the Karnaugh map is having a truth table for the input to output mappings. For our example we’ll use this truth table. This is one of many truth tables that satisfies our equation, so we are working backwards a bit, but hopefully it still makes sense. Usually you would start with the truth table and get a Boolean equation, not the other way around.
The next thing we do is make our karnaugh map by making a square 2×2 grid where one side of the square is the possible A values, the other side is the possible B values, and the contents of the grid cells are the values we want the formula to come out to be:
Next, what you do is circle all 1’s that are in groups of a power of two (one item or two items). Doing that, we get this:
Looking at what we circled, we can see that both values of are involved in our group, so doesn’t matter to the output. We can also see that is not involved in any places where there is a 1, so we can ignore that too. All that leaves is , which is our final, and most minimal answer.
That agrees with the Boolean algebra solution, but came without having to remember any identities. Hooray!
Two Variable Karnaugh Map: Overlaps
If there were multiple groups, you would combine each group with OR to get the final answer. Groups are also allowed to overlap! For instance, let’s look at this truth table to start out:
Turning that into a Karnaugh map, we get this:
Next when it’s time to circle our groups, we have two groups, and they overlap! Here is the first group, which is the same as before:
That group can be expressed as just B.
The other group is this:
That group can be expressed as just A.
Lastly, we OR our groups together, aka we sum our products, and we get as an answer, which in other words is just A OR B. Check out the truth table and you can see that it is indeed a truth table for OR!
Two Variable Karnaugh Map: Single Sized Groups
What if we don’t have groups of two though, what if we only have groups of one? Let’s explore that real quick with the following truth table:
That becomes this Karnaugh map:
We once again have two groups, but they are each of size one, which is totally ok!
The upper left group is expressed as , while the lower right group is expressed as . We OR those two groups together to get the answer: . That’s all there is to it.
Four Variable Karnaugh Map: Don’t Care Values
Let’s get a little more sophisticated and see how we would handle four input variables (We could go to three variables next but after learning two and four it’ll be easy to see how to do three). We will start with a truth table, but our truth table will only contain the input values we care about. We’ll omit the ones we don’t care about.
We’ll put 1’s and 0’s into the Karnaugh map to match our truth table, but put x’s where the output wasn’t listed. These are “don’t care” values, where they could either be 0’s or 1’s, depending on whichever is more convinient for us when simplifying. We are also going to change how we label the map a bit.
In this case, even with the wild card don’t care values, we still just have two 1 item groups, that we OR together to get the answer:
Note that we could factor out the CD and make it into the below, but then it would no longer be in a sum of products form.
You might also have noticed the strange ordering of the values in the table: 00, 01, 11, 10. Normally doesn’t 2 (10) come before 3 (11)? It does, except in this case, we only want to change one variable at a time between neighboring cells. Going from 01 to 11 means that the first bit changed, while going from 01 to 10 means that two bits changed, so isn’t useful for us finding groups. The order that the numbers are in is actually called Gray Code, named after Frank Grey (Wikipedia: Gray Code).
Four Variable Karnaugh Map: Larger Groups
When dealing with karnaugh maps, like I said before, the groups have to be a size of a power of two, but interestingly it can be a power of two on each axis. So valid groups include 4×1, 2×1, 2×2, 4×2 and others. Let’s take a look at one where we encounter a 2×2 group.
Let’s start with the truth table:
That gives us the Karnaugh map:
There are two groups there. The first is the 2×2 group below and is the intersection of where B is 1, and D is 1, so can be represented as BD.
The second group is a 1×2 group that overlaps the first, and is where A,C and D are 1, but B can be either 0 or 1. That makes it able to be represented as ACD.
We combine those groups with OR to get the answer:
Four Variable Karnaugh Map: Wrap Around
Interestingly, you can make groups by wrapping around the edges of the Karnaugh map, either horizontally or vertically. Let’s start with a truth table:
That gives us the Karnaugh map:
Here is the group highlighted below, which is represented as , which is also the answer:
Two Variable Karnaugh Map: Handling Redundant Info
If you are like me, you might be wondering – If Karnaugh maps can give you the minimal sum of products expression for a truth table, how does it deal with redundant information or solutions that are of equal size, so it’s ambiguous which to choose?
For instance, Let’s go with the truth table table below. All other inputs not listed are “don’t care” values.
It’s obvious that the output bit corresponds exactly to both A and B separately. Which one does it choose, or does it make some more complex expression that involves both?
Here is the Karnaugh map:
Well, the disambiguation comes up now that you – the pattern finder in the Karnaugh map – chooses between the two possible groups.
One answer, which is perfectly valid is the below, which is just .
The other answer, which is also perfectly valid, is the below, which is just
So, the disambiguation / simplification is left up to the user to choose, but yes, it still comes up with a minimal sum of products answer, and doesn’t try to incorporate both bits into a more complex logic operation.
The act of turning a truth table into a logical expression is called logical synthesis, if you want to read more along those lines.
You might be wondering if because there is a sum of products form, if there is also a product of sums form? There is in fact, and you can get that form from Karnaugh maps as well. It may result in a more optimal logical expression. More info on that here: Is Karnaugh Map possible for Maxterms?.
You might be tempted to bring a higher number of variables into the mix. Be warned… adding a 5th variable makes the Karnaugh map into a 4x4x2 3d shape. Adding a 6th variable makes it into a 4x4x4 cube. Adding a 7th variable makes it into a 4x4x4x2 hypercube, and the pattern continues.
For higher numbers of inputs, people will often use a different algorithm instead, that I hope to write a post on before too long. You can read about it here: Wikipedia: Quine–McCluskey algorithm
Lastly, you might be wondering, what do i do if i have M input bits, and N output bits? How can I make a circuit or a set of instructions to generate a minimal logical expression to encompass that?
Well, one simple way is to handle each bit separately and have N Karnaugh maps each having M variables. A problem there though is that computers do operations on multiple bits at the same time with most operations, so having each bit do it’s calculations without considering sharing instructions with another bit leaves some efficiency on the table.
I’m not sure of any better algorithms currently, but I’ve asked on stack exchange so there may be some more info there by the time you read this:
Algorithms for logical synthesis of multiple output bits?