Not sure if this is the right StackExchange site, but back in college (20 years ago) I took a Digital Systems Design class where we learned how to reverse engineer a boolean function to meet the requirements set forth in a logic table.

If I recall correctly, the logic table looked something like this:

Input A         Input B        Input C       Output (z)
T               T              T             F
T               T              F             T
T               F              T             F
T               F              F             T
F               T              T             F
F               T              F             T
F               F              T             T
F               F              F             T

This means there are five (5) truth conditions:

F(A,B,C) = true when = (A + B + !C) ||
                       (A + !B + !C) ||
                       (!A + B + !C) ||
                       (!A + !B + C) ||
                       (!A + !B + !C)

There was some type of math involved but it allowed you to take the logic table and convert it into a simplified boolean function that accepted A, B, C (any number of inputs) as arguments and always produced the desired output (z).

Can someone verify whether I've modeled this correctly, and perhaps help me work through this one simplification so that I can see it in action? I actually have to do this with a real-world logic table that's fairly complicated but if I see a simple example I should be able to extrapolate.

  • 1
    $\begingroup$ The full table directly specifies a sum of minterms. You can try Boolean expression minimisation to reduce the number and/or length of terms. You can go multi-level expressions/logic. $\endgroup$
    – greybeard
    Oct 4, 2022 at 14:06
  • $\begingroup$ Ahhh thanks @greybeard (+1) it was simplification. I have updated my question with a simple table that could serve as an example. $\endgroup$ Oct 4, 2022 at 15:28
  • 1
    $\begingroup$ (Or just $¬C ∨ ¬A¬BC$) $\endgroup$
    – greybeard
    Oct 4, 2022 at 17:39
  • $\begingroup$ Very interesting, if you would be generous enough to provide an answer that shows how you arrived at that simplification, I would be grateful, would give you the green check, and would also be able to carry this with me on future problems -- thanks again! $\endgroup$ Oct 4, 2022 at 18:00
  • 2
    $\begingroup$ Karnaugh-Veitch, actually. But the way you tabulated the minterms, it's not that hard to spot it there, too, especially if you swap the last two terms. (To think I left developing IC design tools one third of a century ago…) $\endgroup$
    – greybeard
    Oct 4, 2022 at 18:37


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Browse other questions tagged or ask your own question.