In a binary world, things can have two possible states. We call the two states as TRUE and FALSE.

The two states are also known as LOGIC HIGH STATE and LOGIC LOW STATE, respectively.

In this binary world, everything must be in one of the two possible states {TRUE, FALSE}.
We can perform various logical operations on these two states, for example AND, OR, NOT.

The sun rises in the east TRUE

The earth is bigger than the sun FALSE
Albert Einstein was a physicist FALSE Actually, Einstein got the noble
AND for his explanation of photo
he was awarded the noble prize for his work in special relativity electric effect.
Richard Feynman used to play bongo TRUE I don’t know whether he
OR played violine or not. However,
He used to play violine we know that he used to play
bongo. Hence this statement is
true.

AND, OR are binary logical operators.

The result of AND operation is TRUE if and only if both the operands (statements) are TRUE.
The result of OR operation is TRUE if and only if any of the two operands (statements) are TRUE.

That means
FALSE AND FALSE = FALSE FALSE OR FALSE = FALSE
FALSE AND TRUE = FALSE FALSE OR TRUE = TRUE
TRUE AND FALSE = FALSE TRUE OR FALSE = TRUE
TRUE AND TRUE = TRUE TRUE OR TRUE = TRUE

Symbols:
Denote TRUE with the symbols 1 and
FALSE with the 0.

Denote AND operation with the symbol ⋅ and

OR operation with the symbol + and

Let 𝑥, 𝑦, 𝑧 be binary variables which can take either of the two values: {TRUE, FALSE} i.e. {1,0}
Suppose 𝑧 = 𝑨𝑵𝑫(𝑥, 𝑦) = (𝑥 𝑨𝑵𝑫 𝑦) = (𝑥 ⋅ 𝑦) Suppose 𝑧 = 𝑶𝑹(𝑥, 𝑦) = (𝑥 𝑶𝑹 𝑦) = (𝑥 + 𝑦)
𝑧 will be 1 if and only if both 𝑥 and 𝑦 are 1. 𝑧 will be 1 if and only if at least one of 𝑥 and 𝑦 is 1.
We may summarize this using a table: We may summarize this using a table:
Arguments Result Arguments Result
𝒙 𝒚 𝒛 = (𝒙 ⋅ 𝒚) 𝒙 𝒚 𝒛 = (𝒙 + 𝒚)
0 0 0 0 0 0
0 1 0 0 1 1
1 0 0 1 0 1
1 1 1 1 1 1

This type of a table is known as a Truth Table This type of a table is known as a Truth Table

(𝑥 ⋅ 𝑦) is often written as 𝑥𝑦 omitting the dot.

Generalization:
𝑥1 𝑥2 𝑥3 … 𝑥𝑛
= 𝐴𝑁𝐷(𝑥1 , 𝑥2 , 𝑥3 , … , 𝑥𝑛 )
= 𝑥1 𝐴𝑁𝐷 𝑥2 𝐴𝑁𝐷 𝑥3 … 𝐴𝑁𝐷 𝑥𝑛
= (((𝑥1 𝐴𝑁𝐷 𝑥2 ) 𝐴𝑁𝐷 𝑥3 ) … 𝐴𝑁𝐷 𝑥𝑛 )
1 𝑖𝑓 𝒂𝒍𝒍 𝑜𝑓 𝑥1 , 𝑥2 , 𝑥3 , … , 𝑥𝑛 𝑎𝑟𝑒 1
={
0 𝑖𝑓 𝒂𝒏𝒚 𝑜𝑓 𝑥1 , 𝑥2 , 𝑥3 , … , 𝑥𝑛 𝑖𝑠 0

𝑥1 + 𝑥2 + 𝑥3 + ⋯ + 𝑥𝑛
= 𝑂𝑅(𝑥1 + 𝑥2 + 𝑥3 + ⋯ + 𝑥𝑛 )
= 𝑥1 𝑂𝑅 𝑥2 𝑂𝑅 𝑥3 … 𝑂𝑅 𝑥𝑛
= (((𝑥1 𝑂𝑅 𝑥2 ) 𝑂𝑅 𝑥3 ) … 𝑂𝑅 𝑥𝑛 )
1 𝑖𝑓 𝒂𝒏𝒚 𝑜𝑓 𝑥1 , 𝑥2 , 𝑥3 , … , 𝑥𝑛 𝑎𝑟𝑒 1
={
0 𝑖𝑓 𝒂𝒍𝒍 𝑜𝑓 𝑥1 , 𝑥2 , 𝑥3 , … , 𝑥𝑛 𝑖𝑠 0

NOT is a unary logical operator. It is also called a Complement operator

NOT(TRUE) = FALSE
NOT(FALSE) = TRUE

Symbols: NOT (𝑥) is denoted as 𝑥̅ or 𝑥′

Truth table:
Argument Result
𝒙 𝒛=𝒙 ̅
0 1
1 0

Exercise: Justify the followings

(1) 𝒙 + 𝟏 = 𝟏
(2) 𝒙 + 𝟎 = 𝒙
(3) 𝒙 ⋅ 𝟏 = 𝒙
(4) 𝒙 ⋅ 𝟎 = 𝟎
(5) 𝒙 + 𝒙̅=𝟏
̅=𝟎
(6) 𝒙 ⋅ 𝒙

𝒙 ⋅ (𝒚 + 𝒛) = 𝒙 ⋅ 𝒚 + 𝒙 ⋅ 𝒛
Proof:
One way to proof it is through a truth table
𝒙 𝒚 𝒛 𝒙 ⋅ (𝒚 + 𝒛) 𝒙⋅𝒚+𝒙⋅𝒛
0 0 0 0 ⋅ (0 + 0) = 0 0 ⋅ 0 + 0 ⋅ 0 = 0
0 0 1 0 ⋅ (0 + 1) = 0 0 ⋅ 0 + 0 ⋅ 1 = 0
0 1 0 0 ⋅ (1 + 0) = 0 0 ⋅ 1 + 0 ⋅ 0 = 0
0 1 1 0 ⋅ (1 + 1) = 0 0 ⋅ 1 + 0 ⋅ 1 = 0
1 0 0 1 ⋅ (0 + 0) = 0 1 ⋅ 0 + 1 ⋅ 0 = 0
1 0 1 1 ⋅ (0 + 1) = 1 1 ⋅ 0 + 1 ⋅ 1 = 1
1 1 0 1 ⋅ (1 + 0) = 1 1 ⋅ 1 + 1 ⋅ 0 = 1
1 1 1 1 ⋅ (1 + 1) = 1 1 ⋅ 1 + 1 ⋅ 1 = 1
Last two columns are the same. That proves the statement.
Example: 𝑥 + 𝑥𝑦 = 𝑥
Proof:
𝑥 + 𝑥𝑦
= 𝑥(𝑦 + 𝑦̅) + 𝑥𝑦
= 𝑥𝑦 + 𝑥𝑦̅ + 𝑥𝑦
= (𝑥𝑦 + 𝑥𝑦) + 𝑥𝑦̅
= 𝑥𝑦 + 𝑥𝑦̅
= 𝑥(𝑦 + 𝑦̅)
=𝑥⋅1
=𝑥

𝒙 + (𝒚 ⋅ 𝒛) = (𝒙 + 𝒚) ⋅ (𝒙 + 𝒛)
Proof:
(𝑥 + 𝑦) ⋅ (𝑥 + 𝑧)
= 𝑥𝑥 + 𝑦𝑥 + 𝑥𝑧 + 𝑦𝑧
= (𝑥 + 𝑥𝑦) + 𝑥𝑧 + 𝑦𝑧
= 𝑥 + 𝑥𝑧 + 𝑦𝑧
= 𝑥 + 𝑦𝑧

De Morgan's laws:

(1) ̅̅̅̅̅̅̅̅
(𝒙 ⋅ 𝒚) = 𝒙
̅+𝒚 ̅ ̅̅̅̅̅̅̅̅̅̅
(2) (𝒙 ̅⋅𝒚
+ 𝒚) = 𝒙 ̅
⇒ ̅̅̅̅̅̅̅
𝑥̅ + 𝑦̅ = (𝑥 ⋅ 𝑦) ⇒ ̅̅̅̅̅̅
𝑥̅ ⋅ 𝑦̅ = (𝑥 + 𝑦)

Proofs using truth tables

(1) (2)
𝒙 𝒚 ̅̅̅̅̅̅̅̅
(𝒙 ⋅ 𝒚) ̅+𝒚
𝒙 ̅ 𝒙 𝒚 ̅̅̅̅̅̅̅̅̅̅
(𝒙 + 𝒚) ̅⋅𝒚
𝒙 ̅
̅̅̅̅̅̅̅̅ ̅
0 0 (0 ⋅ 0) = 1 0 + 0 = 1̅ ̅̅̅̅̅̅̅̅̅̅ ̅ ̅
0 0 (0 + 0) = 1 0 ⋅ 0 = 1
0 1 ̅̅̅̅̅̅̅̅
(0 ⋅ 1) = 1 0̅ + 1̅ = 1 0 1 ̅̅̅̅̅̅̅̅̅̅
(0 + 1) = 0 0̅ ⋅ 1̅ = 0
(1 ⋅ 0) = 1 1̅ + 0̅ = 1
1 0 ̅̅̅̅̅̅̅̅ (1 + 0) = 0 1̅ ⋅ 0̅ = 0
1 0 ̅̅̅̅̅̅̅̅̅̅
(1 ⋅ 1) = 0 1̅ + 1̅ = 0
1 1 ̅̅̅̅̅̅̅̅ (1 + 1) = 0 1̅ ⋅ 1̅ = 0
1 1 ̅̅̅̅̅̅̅̅̅̅
The last two columns are the same. The last two columns are the same.

This can be generalized for more than two variables:

(1) ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
(𝒙𝟏 ⋅ 𝒙𝟐 ⋅ 𝒙𝟑 ⋅ … ⋅ 𝒙𝒏 ) = ̅̅̅𝒙𝟏 + ̅̅̅
𝒙𝟐 + ̅̅̅
𝒙𝟑 + ⋯ + 𝒙 ̅̅̅
𝒏
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
(2) (𝒙𝟏 + 𝒙𝟐 + 𝒙𝟑 + ⋯ + 𝒙𝒏 ) = ̅̅̅ 𝒙𝟏 ⋅ ̅̅̅
𝒙𝟐 ⋅ ̅̅̅
𝒙𝟑 ⋅ … ⋅ ̅̅̅
𝒙𝒏
Justify yourselves.

Circuit Symbols: Also known as GATES

Inputs Inputs
Output Output Input Output

AND GATE OR GATE NOT GATE

𝑧 = 𝑨𝑵𝑫(𝑥, 𝑦) 𝑧 = 𝑶𝑹(𝑥, 𝑦) 𝑧 = 𝑵𝑶𝑻(𝑥)
 𝑧 = 𝑨𝑵𝑫(𝑤, 𝑥, 𝑦) 𝑧 = 𝑶𝑹(𝑤, 𝑥, 𝑦)

More logical operators

NAND: NOR:
Definition: Definition:
𝑁𝐴𝑁𝐷(𝑥, 𝑦) = 𝑁𝑂𝑇(𝐴𝑁𝐷(𝑥, 𝑦)) = ̅̅̅̅̅̅
𝑥⋅𝑦 𝑁𝑂𝑅(𝑥, 𝑦) = 𝑁𝑂𝑇(𝑂𝑅(𝑥, 𝑦)) = ̅̅̅̅̅̅̅
𝑥+𝑦
𝑁𝐴𝑁𝐷(𝑥1 , 𝑥2 , … , 𝑥𝑛 ) = 𝑁𝑂𝑇(𝐴𝑁𝐷(𝑥1 , 𝑥2 , … , 𝑥𝑛 )) 𝑁𝑂𝑅(𝑥1 , 𝑥2 , … , 𝑥𝑛 ) = 𝑁𝑂𝑇(𝑂𝑅(𝑥1 , 𝑥2 , … , 𝑥𝑛 ))

NAND GATE NOR GATE

𝑧 = 𝑵𝑨𝑵𝑫(𝑤, 𝑥, 𝑦) = 𝑤𝑥𝑦
̅̅̅̅̅̅ 𝑧 = 𝑵𝑶𝑹(𝑤, 𝑥, 𝑦) = ̅̅̅̅̅̅̅̅̅̅̅̅̅
𝑤+𝑥+𝑦

NAND and NOR Gates are called the Universal Gates

Because any logical gate can be made by combining one or more NAND gates appropriately.
Similarly, any logical gate can be made by combining one or more NOR gates appropriately.
Realizing a NOT gate from a NAND gate Realizing a NOT gate from a NOR gate

= ̅̅̅̅̅̅
𝑥 ⋅ 𝑥 = 𝑥̅ = ̅̅̅̅̅̅̅
𝑥 + 𝑥 = 𝑥̅

Realizing a AND gate from NAND gates Realizing a AND gate from NOR gates

𝑥̅
𝑥⋅𝑦
̅̅̅̅̅̅

= ̅̅̅̅̅̅
𝑥⋅𝑦
=𝑥⋅𝑦
= ̅̅̅̅̅̅̅
𝑥̅ + 𝑦̅
=𝑥⋅𝑦
𝑦̅

Realizing a OR gate from NAND gates Realizing a OR gate from NOR gates

𝑥̅
̅̅̅̅̅̅̅
𝑥+𝑦

= ̅̅̅̅̅̅̅
𝑥+𝑦
=𝑥+𝑦
= ̅̅̅̅̅̅
𝑥̅ ⋅ 𝑦̅
=𝑥+𝑦
𝑦̅
More Logical operators:
XOR (Exclusive OR) XNOR
Definition: Definition:
𝑋𝑂𝑅(𝑥, 𝑦) = 𝑥 ⊕ 𝑦 = 𝑥𝑦̅ + 𝑥̅ 𝑦 𝑋𝑁𝑂𝑅(𝑥, 𝑦) = 𝑥 ⊙ 𝑦 = 𝑥𝑦 + 𝑥̅ 𝑦̅
𝑋𝑂𝑅(𝑥, 𝑦) is TRUE iff x and y are not equal 𝑋𝑁𝑂𝑅(𝑥, 𝑦) is TRUE iff x and y are equal

𝒙 𝒚 𝑥 ⊕ 𝑦 = 𝑥𝑦̅ + 𝑥̅ 𝑦 𝒙 𝒚 𝑥 ⊙ 𝑦 = 𝑥𝑦 + 𝑥̅ 𝑦̅
0 0 0 0 0 1
0 1 1 0 1 0
1 0 1 1 0 0
1 1 0 1 1 1

=𝑥⊕𝑦 =𝑥⊙𝑦

𝑋𝑂𝑅(𝑥1 , 𝑥2 , 𝑥3 , … , 𝑥𝑛 ) 𝑋𝑁𝑂𝑅(𝑥1 , 𝑥2 , 𝑥3 , … , 𝑥𝑛 )
= 𝑥1 ⊕ 𝑥2 ⊕ 𝑥3 ⊕ … ⊕ 𝑥𝑛 = 𝑥1 ̅̅̅
⊕ 𝑥2 ̅̅̅
⊕ 𝑥3 ̅̅̅
⊕ … ̅̅̅
⊕ 𝑥𝑛
= ((𝑥1 ⊕ 𝑥2 ) ⊕ 𝑥3 ) … ⊕ 𝑥𝑛 = 𝑥1 ⊙ 𝑥2 ⊙ 𝑥3 ⊙ … ⊙ 𝑥𝑛
The result will be true iff odd number of = ((𝑥1 ⊙ 𝑥2 ) ⊙ 𝑥3 ) … ⊙ 𝑥𝑛
arguments are true. The result will be true iff even number of
(Justify using method of induction) arguments are true.
(Justify using method of induction)
XNOR = NOT(XOR)

Binary logic is also known as the Boolean logic after the name of the mathematician George Boole.

Boolean functions

Suppose, 𝑤, 𝑥, 𝑦, and 𝑧 are binary (Boolean) variables and 𝑧 = (𝑤 + 𝑥̅ ⋅ 𝑦) ⊕ (𝑥 + 𝑦̅). Here the value of 𝑧
depends on the values of 𝑤, 𝑥, and 𝑦. We say 𝑧 is a Boolean function of 𝑤, 𝑥, and 𝑦. We may write 𝑧 =
𝑓(𝑤, 𝑥, 𝑦).

Very Special Boolean Functions: Minterms and Maxterms:

Minterms: Suppose, 𝑤, 𝑥, and 𝑦 are three independent Boolean variables. Minterms are some very special
Boolean functions as defined below:
𝑚0 = 𝑤̅𝑥̅ 𝑦̅
𝑚1 = 𝑤̅𝑥̅ 𝑦
𝑚2 = 𝑤̅𝑥𝑦̅
𝑚3 = 𝑤̅𝑥𝑦
𝑚4 = 𝑤𝑥̅ 𝑦̅
𝑚5 = 𝑤𝑥̅ 𝑦
𝑚6 = 𝑤𝑥𝑦̅
𝑚7 = 𝑤𝑥𝑦
n independent Boolean variables yield 2𝑛 minterms.
For a particular set of values of the independent variables, exactly one minterm becomes 1, the remaining
minterms become zero. This becomes clear in the truth table of the minterms shown below:
𝒘 𝒙 𝒚 𝑚0 𝑚1 𝑚2 𝑚3 𝑚4 𝑚5 𝑚6 𝑚7
=𝑤 ̅𝑥̅ 𝑦̅ =𝑤𝑥𝑦 = 𝑤 ̅𝑥𝑦̅ =𝑤𝑥𝑦 = 𝑤𝑥̅ 𝑦̅ = 𝑤𝑥̅ 𝑦 = 𝑤𝑥𝑦̅ = 𝑤𝑥𝑦
0 0 0 1 0 0 0 0 0 0 0
0 0 1 0 1 0 0 0 0 0 0
0 1 0 0 0 1 0 0 0 0 0
0 1 1 0 0 0 1 0 0 0 0
1 0 0 0 0 0 0 1 0 0 0
1 0 1 0 0 0 0 0 1 0 0
1 1 0 0 0 0 0 0 0 1 0
1 1 1 0 0 0 0 0 0 0 1

Maxterms: Now we define Maxterms

𝑚0 = ̅̅̅̅̅̅
𝑀0 = ̅̅̅̅ 𝑤̅𝑥̅ 𝑦̅ = 𝑤 + 𝑥 + 𝑦
𝑀1 = ̅̅̅̅
𝑚1 = 𝑤̅̅̅̅̅̅
̅𝑥̅ 𝑦 = 𝑤 + 𝑥 + 𝑦̅
𝑀2 = ̅̅̅̅
𝑚2 = 𝑤̅̅̅̅̅̅
̅𝑥𝑦̅ = 𝑤 + 𝑥̅ + 𝑦
𝑚3 = ̅̅̅̅̅̅
𝑀3 = ̅̅̅̅ 𝑤̅𝑥𝑦 = 𝑤 + 𝑥̅ + 𝑦̅
𝑚4 = ̅̅̅̅̅̅
𝑀4 = ̅̅̅̅ 𝑤𝑥̅ 𝑦̅ = 𝑤̅+𝑥+𝑦
𝑚5 = ̅̅̅̅̅̅
𝑀5 = ̅̅̅̅ 𝑤𝑥̅ 𝑦 = 𝑤 ̅ + 𝑥 + 𝑦̅
𝑀6 = ̅̅̅̅ ̅̅̅̅̅̅
𝑚6 = 𝑤𝑥𝑦̅ = 𝑤 ̅ + 𝑥̅ + 𝑦
𝑀7 = ̅̅̅̅
𝑚7 = 𝑤𝑥𝑦
̅̅̅̅̅̅ = 𝑤̅ + 𝑥̅ + 𝑦̅

n independent Boolean variables yield 2𝑛 maxterms.

For a particular set of values of the independent variables, exactly one maxterm becomes 0, the remaining
minterms become 1. This becomes clear in the truth table of the minterms shown below:
𝒘 𝒙 𝒚 𝑀0 𝑀1 𝑀2 𝑀3 𝑚4 𝑀5 𝑀6 𝑀7
𝑤+𝑥+𝑦 𝑤 + 𝑥 + 𝑦̅ 𝑤 + 𝑥̅ + 𝑦 𝑤 + 𝑥̅ + 𝑦̅ 𝑤
̅ +𝑥+𝑦 𝑤
̅ + 𝑥 + 𝑦̅ 𝑤
̅ + 𝑥̅ + 𝑦 𝑤+𝑥+𝑦
0 0 0 0 1 1 1 1 1 1 1
0 0 1 1 0 1 1 1 1 1 1
0 1 0 1 1 0 1 1 1 1 1
0 1 1 1 1 1 0 1 1 1 1
1 0 0 1 1 1 1 0 1 1 1
1 0 1 1 1 1 1 1 0 1 1
1 1 0 1 1 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1 0

Please note the pattern below:

𝒘 𝒙 𝒚 Which minterm is 1 ? Which Maxterm is 0 ?
0 0 0 𝑚0 = 𝑤̅𝑥̅ 𝑦̅ 𝑀0 = 𝑤 + 𝑥 + 𝑦
0 0 1 𝑚1 = 𝑤̅𝑥̅ 𝑦 𝑀1 = 𝑤 + 𝑥 + 𝑦̅
0 1 0 𝑚2 = 𝑤̅𝑥𝑦̅ 𝑀2 = 𝑤 + 𝑥̅ + 𝑦
0 1 1 𝑚3 = 𝑤̅𝑥𝑦 𝑀3 = 𝑤 + 𝑥̅ + 𝑦̅
1 0 0 𝑚4 = 𝑤𝑥̅ 𝑦̅ 𝑀4 = 𝑤
̅+𝑥+𝑦
1 0 1 𝑚5 = 𝑤𝑥̅ 𝑦 𝑀5 = 𝑤
̅ + 𝑥 + 𝑦̅
1 1 0 𝑚6 = 𝑤𝑥𝑦̅ 𝑀6 = 𝑤
̅ + 𝑥̅ + 𝑦
1 1 1 𝑚7 = 𝑤𝑥𝑦 𝑀7 = 𝑤
̅ + 𝑥̅ + 𝑦̅
Truth table of an arbitrary Boolean function:
Consider any arbitrary Boolean function 𝑧 = (𝑤 + 𝑥̅ ⋅ 𝑦) ⊕ (𝑥 + 𝑦̅)
We may tabulate the values of 𝑧 for different values of 𝑤, 𝑥, and 𝑦 in the form of a truth table:
We may also say
𝒘 𝒙 𝒚 𝒛 = (𝒘 + 𝒙 ̅ ⋅ 𝒚) ⊕ (𝒙 + 𝒚
̅) Thus z=1 when z=1 when
̅
0 0 0 (0 + 0 ⋅ 0) ⊕ (0 + 0) = 1 ̅ ((w=0) AND (x=0) AND (y=0)) 𝑤
̅𝑥̅ 𝑦̅ = 1
̅
0 0 1 (0 + 0 ⋅ 1) ⊕ (0 + 1) = 1 ̅ OR ((w=0) AND (x=0) AND (y=1)) OR 𝑤
̅𝑥̅ 𝑦 = 1
0 1 0 (0 + 1̅ ⋅ 0) ⊕ (1 + 0̅) = 1 OR ((w=0) AND (x=1) AND (y=0)) OR 𝑤 ̅𝑥𝑦̅ = 1
0 1 1 (0 + 1̅ ⋅ 1) ⊕ (1 + 1̅) = 1 OR ((w=0) AND (x=1) AND (y=1)) OR 𝑤 ̅𝑥𝑦 = 1
̅
1 0 0 (1 + 0 ⋅ 0) ⊕ (0 + 0) = 0 ̅
1 0 1 (1 + 0̅ ⋅ 1) ⊕ (0 + 1̅) = 1 OR ((w=1) AND (x=0) AND (y=1)) OR 𝑤𝑥̅ 𝑦 = 1
1 1 0 (1 + 1̅ ⋅ 0) ⊕ (1 + 0̅) = 0
1 1 1 (1 + 1̅ ⋅ 1) ⊕ (1 + 1̅) = 0 Therefore,
𝒛=𝒘 ̅𝒙̅𝒚 ̅+𝒘 ̅𝒙̅𝒚 + 𝒘 ̅
̅ 𝒙𝒚
+𝒘 ̅𝒚
̅ 𝒙𝒚 + 𝒘𝒙
…(1)
𝑧=𝑤 ̅𝑥̅ 𝑦̅ + 𝑤
̅𝑥̅ 𝑦 + 𝑤
̅𝑥𝑦̅ + 𝑤̅𝑥𝑦 + 𝑤𝑥̅ 𝑦…(1)
This form of expressing a Boolean function is known as Sum Of Products (SOP) or Disjunctive Normal Form
(DNF).

The Boolean function in equation (1) You can verify that

can also be written as 𝑤 𝑥 𝑦 𝑚0 𝑚1 𝑚2 𝑚3 𝑚5 𝑧=
𝑚0 + 𝑚1 + 𝑚2 + 𝑚3 + 𝑚5
𝑧=𝑤 ̅𝑥̅ 𝑦̅ + 𝑤
̅𝑥̅ 𝑦 + 𝑤
̅𝑥𝑦̅ + 𝑤
̅𝑥𝑦 + 𝑤𝑥̅ 𝑦
= 𝑚0 + 𝑚1 + 𝑚2 + 𝑚3 + 𝑚5 0 0 0 1 0 0 0 0 1
… (2) 0 0 1 0 1 0 0 0 1
= ∑(0,1,2,3,5) (in short) 0 1 0 0 0 1 0 0 1
0 1 1 0 0 0 1 0 1
1 0 0 0 0 0 0 0 0
1 0 1 0 0 0 0 1 1
1 1 0 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0
In this way, any Boolean function can be expressed as a sum of the appropriate minterms.

Further, You can verify that

𝑧 = 𝑚0 + 𝑚1 + 𝑚2 + 𝑚3 + 𝑚5 𝑤 𝑥 𝑦 𝑀4 𝑀6 𝑀7 𝑧=
̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
= 𝑚4 + 𝑚6 + 𝑚7 𝑀 4 𝑀6 ⋅ 𝑀7
⋅
= ̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅̅
̅̅̅̅
𝑀4 + ̅̅̅̅
𝑀6 + ̅̅̅̅
𝑀7 0 0 0 1 1 1 1
= 𝑀4 ⋅ 𝑀6 ⋅ 𝑀7 0 0 1 1 1 1 1
… (3) 0 1 0 1 1 1 1
= Π(4,6,7) (in short) 0 1 1 1 1 1 1
1 0 0 0 1 1 0
1 0 1 1 1 1 1
1 1 0 1 0 1 0
1 1 1 1 1 0 0
In this way, any Boolean function can be expressed as a product of the appropriate maxterms.

Again
𝑧 = 𝑀4 ⋅ 𝑀6 ⋅ 𝑀7 = (𝑤 ̅ + 𝑥 + 𝑦 )(𝑤
̅ + 𝑥̅ + 𝑦)(𝑤
̅ + 𝑥̅ + 𝑦̅ )
This form of expressing a Boolean function is known as Product Of Sums (POS) or Conjunctive Normal Form
(CNF).
The function 𝑧 expressed in SOP form through equation (2) can be realized through the following logical
circuit

The function 𝑧 expressed in POS form through equation (3) can be realized through the following logical
circuit
Duality, Consensus theorem