How To design an appropriate logic gate combinatin for a given truth table?

Answer 1

A truth table simply shows you the output that corresponds to each combination of inputs for a given Boolean operator. Boolean operator inputs and outputs have only two possible states (true or false) and operators may be unary (one input), binary (two inputs), ternary (three inputs) and so on.

The unary operators are the simplest operators to understand as they only have one input. To cater for all possible outputs we need four unary operators in total:

OP1(0) = 0 | OP1(1) = 0

OP2(0) = 0 | OP2(1) = 1

OP3(0) = 1 | OP3(1) = 0

OP4(0) = 1 | OP4(1) = 1

OP1 returns false regardless of whether the input is true or false.

OP2 returns the state of the input.

OP3 returns the inverted state of the input.

OP4 returns true regardless of whether the input is true or false.

Of these four operators, OP3 is the most interesting; its truth table corresponds with that of the NOT operator truth table.

NOT (false) = true

NOT (true) = false

Although OP1, OP2 and OP4 logically exist as operators, OP1 and OP4 have no practical uses and OP2 is implicit.

Binary operators have two inputs thus each operator has four input combinations:

OP (0, 0)

OP (0, 1)

OP (1, 0)

OP (1, 1)

With four outputs, we need 16 operators to produce all the possible output combinations:

OP0(0, 0) = 0 | OP0(0, 1) = 0 | OP0(1, 0) = 0 | OP0(1, 1) = 0

OP1(0, 0) = 0 | OP1(0, 1) = 0 | OP1(1, 0) = 0 | OP1(1, 1) = 1

OP2(0, 0) = 0 | OP2(0, 1) = 0 | OP2(1, 0) = 1 | OP2(1, 1) = 0

OP3(0, 0) = 0 | OP3(0, 1) = 0 | OP3(1, 0) = 1 | OP3(1, 1) = 1

OP4(0, 0) = 0 | OP4(0, 1) = 1 | OP4(1, 0) = 0 | OP4(1, 1) = 0

OP5(0, 0) = 0 | OP5(0, 1) = 1 | OP5(1, 0) = 0 | OP5(1, 1) = 1

OP6(0, 0) = 0 | OP6(0, 1) = 1 | OP6(1, 0) = 1 | OP6(1, 1) = 0

OP7(0, 0) = 0 | OP7(0, 1) = 1 | OP7(1, 0) = 1 | OP7(1, 1) = 1

OP8(0, 0) = 1 | OP8(0, 1) = 0 | OP8(1, 0) = 0 | OP8(1, 1) = 0

OP9(0, 0) = 1 | OP9(0, 1) = 0 | OP9(1, 0) = 0 | OP9(1, 1) = 1

OPa(0, 0) = 1 | OPa(0, 1) = 0 | OPa(1, 0) = 1 | OPa(1, 1) = 0

OPb(0, 0) = 1 | OPb(0, 1) = 0 | OPb(1, 0) = 1 | OPb(1, 1) = 1

OPc(0, 0) = 1 | OPc(0, 1) = 1 | OPc(1, 0) = 0 | OPc(1, 1) = 0

OPd(0, 0) = 1 | OPd(0, 1) = 1 | OPd(1, 0) = 0 | OPd(1, 1) = 1

OPe(0, 0) = 1 | OPe(0, 1) = 1 | OPe(1, 0) = 1 | OPe(1, 1) = 0

OPf(0, 0) = 1 | OPf(0, 1) = 1 | OPf(1, 0) = 1 | OPf(1, 1) = 1

From this, given two inputs, a and b, we can observe the following:

OP0 returns false regardless of the input states.

OP1 returns true if both inputs are true: AND (a, b).

OP2 returns true if the first input is true and the second is false: AND (a, NOT (b)).

OP3 returns true if the first input is true: a.

OP4 returns true if the second input is true and the first is false: AND (NOT (a), b).

OP5 returns true if the second input is true: b.

OP6 returns true if one and only one input is true: XOR (a, b).

OP7 returns true if one or both inputs are true: OR (a, b).

OP8 returns false if one or both inputs are true: NOT (OR (a, b)).

OP9 returns false if one and only one input is true: NOT (XOR (a, b)).

OPa returns false if the second input is true: NOT (b).

OPb returns false if the second input is true and the first is false: NOT (AND (NOT (a), b)).

OPc returns false if the first input is true: NOT (a).

OPd returns false if the first input is true and the second is false: NOT (AND (a, NOT (b)).

OPe returns false if both inputs are true: NOT (AND (a, b)).

OPf returns true regardless of the input states.

Note that the lower half of the operator table is simply the inversion of the upper half. E.g., OPc is the same as NOT (OP3).

As before, OP0 and OPf logically exist but have no practical uses. OP1, OP6 and OP7 are the three we use most often, corresponding to the AND, XOR and OR operators respectively:

AND (false, false) = false

AND (false, true) = false

AND (true, false) = false

AND (true, true) = true

XOR (false, false) = false

XOR (false, true) = true

XOR (true, false) = true

XOR (true, true) = false

OR (false, false) = false

OR (false, true) = true

OR (true, false) = true

OR (true, true) = true

OP8 is sometimes implemented as a NOR operator while OPe is sometimes implemented as a NAND operator.

Answer 2

1. Truth tables

Answer 3

k