Boolean Logic Help


I know this is a more project based forum so I may be off topic here, but I am seeking some online resources for my 201 logic class. If anyone knows of a forum, website, tutor, or even YouTube channel that covers Boolean Algebra in depth (Boolean reduction, K Maps, MSOP, MPOS, etc.), I could really use the help. I’m open to paid options as well. Any advice is welcome!


Hey Jake, I think this is totally within the scope of this forum. What are you looking for outside of your book? I assume there is a text for the class? Is it mostly a walkthrough that you’re looking for?

It appears there are a bunch on YouTube, but they all look rather dry (as is Boolean Algebra most days…)


The text is “Logic and Computer Design Fundamentals,” but I have not found its “working through” problems to be very helpful. I’ve found some videos working through basic Boolean identities, but I have been struggling with advanced Boolean reduction, Boolean complements, minimum sum of products, and minimum product of sums. The skill necessary for all of these, and the skill that I need the most help with is reduction. I am hoping to find, ideally, a video series/course, or a website that provides example problems, solutions, and works through problems. Here is an example of a Boolean function that I will have to reduce: ABC + A’CD + BCD + ABD’
Thanks for the help!


Here is an example of MSOP and MPOS that I must solve for.


Wow, I am reminded why I work on analog stuff… :slight_smile:


The Sum of Products (SOP) logic equation implements a logic function using two levels, where the first level consists of AND gates. The second level takes all the outputs of the AND gates and ORs them together.

The MSOP, or Minimal Sum of Products, is a form of SOP where the number of gates (number of products) is minimal and the number of inputs to each gate (number of literals) is minimal. In essence, it implements a logic function using the 2-level AND-OR structure, where the circuit complexity is as small as possible.

Produce a ‘1’ for the following binary inputs:


The following binary inputs are defined as Don’t Care:


This gives the following Karnaugh map:

The aim is now to find a minimum set of the largest blocks (implicants) that will cover all the binary ‘1’s in the Karnaugh map. Each block will translate into an AND gate in the final implementation. The larger the block, the fewer inputs the AND gate will have.

We must use the ‘don’t cares’ to increase the size of a block if possible, as this will then reduce the number of inputs.

Now let’s start covering:

Here X is always ‘1’ and Y is always ‘0’, this gives the following product: XY’

Now, we try to cover the lower right ‘1’s. We can’t cover them using a single product so we end up doing something like this:

In blue: W=1, X=0, Y=1 which gives the product WX’Y.
In green: W=1, X=0, Y=0, Z=1 which gives the product WX’Y’Z.

Our SOP solution is now: XY’ + WX’Y + WX’Y’Z.

We must now ask ourselves the question: can we in any way make the blocks larger?

The answer is: YES. (surpise!)

First, we can extend the blue block to include the top don’t cares:

Now we can reduce the product WX’Y to X’Y. The AND gate now only needs 2 inputs instead of 3!

We can also extend the green block up one cell. This will cause one output ‘1’ to be covered by two blocks. This is not a problem as it doesn’t change the output of the function but it does reduce the number of inputs for the green AND gate:

The green block (W=1, Y=0, Z=1) now gives the following product: WY’Z

Our minimal sum of products implementation then becomes: XY’ + X’Y + WY’Z

Here is the logic circuit:

Hope this helps a little.



@jakeammons, I’m not sure by which method you need to reduce the following equation

but you can generate the following Karnaugh map from that function:

,which, by the same method outlined above, can be covered by ABC + ABD’ + BCD.



Don’t you mean ABC + ABD’ + A’CD?

You’re just testing us right? :wink:

Edit: From the Karnaugh map above you can see that the BCD term hasn’t been outlined as it is redundant and we can therefore simply discard it. But that is the only simplification that can be made.


Hi Rob,

Nope, it was an honest mistake! Thanks for checking my results.
Indeed BCD should be A’CD.

This is why we have software tools that do this kind of simplification for us :slight_smile:
I don’t know of anyone in industry still using these error-prone methods.