Chapter 3: Boolean Algebra & Logic Simplification - Complete Study Notes

NotebookLM Ingestion Compilation

This merged document contains all 7 study notes for Chapter 3: Boolean Algebra & Logic Simplification from ECE 2103 Digital Electronics (Sharif Sir).


Related Concepts: 02 Boolean Algebra Significance & Circuit Minimization | 03 SOP, POS, Canonical & Standard Forms | 06 Boolean Algebra Puzzles & Exam Proofs

3.01 Boolean Algebra Foundations & Duality Principle

Statement of the Duality Principle

The Duality Principle states that every valid Boolean algebraic relation remains mathematically valid if all OR () and AND () operators are interchanged, and all identity elements ( and ) are interchanged, provided the variables and their complements are left unchanged.


1. Duality Transformation Rules

graph TD
    subgraph Duality Transformation Rules
        DualIn[Original Expression F] --> Rule1[Swap + and •]
        Rule1 --> Rule2[Swap 0 and 1]
        Rule2 --> Rule3[Keep Literals x and x' UNCHANGED]
        Rule3 --> DualOut[Dual Expression Dual-F]
    end
    
    subgraph Complement Transformation Rules
        CompIn[Original Expression F] --> CRule1[Swap + and •]
        CRule1 --> CRule2[Swap 0 and 1]
        CRule2 --> CRule3[INVERT Literals: x to x', x' to x]
        CRule3 --> CompOut[Complement Expression F']
    end

Dual vs. Complement

  • Dual (): Swaps operators () and constants () ONLY. Variable complements are untouched ().
  • Complement ( via De Morgan’s): Swaps operators (), constants (), AND complements every literal ().

2. Key Mathematical Proofs

Proof 1: Proving Absorption Law & Its Dual

Theorem: Prove and its dual .

A. Original Identity ():

B. Dual Identity ():


Proof 2: Major Exam Theorem — Dual of XOR Equals Its Complement

Major Term PYQ Theorem (2015 - 12 Marks, 2018 - 10 Marks)

Question: Show mathematically that the Dual of the Exclusive-OR (XOR) function is equal to its Complement (XNOR).

Let .

Step 1: Compute Dual of ()

Apply duality rules to : Expand by distribution: Since and :

Step 2: Compute Complement of ()

Apply De Morgan’s Law to : Expand by distribution:

Conclusion:


3. Huntington Postulates of Boolean Algebra

Syllabus Context: Theoretical Foundation

While less commonly tested in calculation problems, these postulates form the mathematical definition of standard Boolean Algebras.

In 1904, E.V. Huntington formulated a set of postulates to define algebraic structures known as Boolean Algebras:

  1. Closure: The system is closed under both binary operators (OR) and (AND).
  2. Identity Element:
    • There exists an identity element with respect to : .
    • There exists an identity element with respect to : .
  3. Commutative Law: The operators are commutative:
  4. Distributive Law: Each operator distributes over the other:
  5. Complement: For every element , there exists a unique complement element such that:
  6. Distinct Elements: The set contains at least two distinct elements and (where ).

⚠️ Warning for Beginners: Boolean vs. Ordinary Algebra

A student transitioning from high-school math to digital electronics will make critical assumptions that break down in digital design. Highlight these five fundamental differences:

  • No Associative Law in Postulates: The associative laws— and —are not part of Huntington’s baseline axioms. However, they can be mathematically proven as theorems using the other postulates.
  • The Dual Distributive Law: In ordinary algebra, . In Boolean algebra, this is completely valid and is used constantly for POS simplification.
  • No Inverse Elements: Boolean algebra has no additive inverse () and no multiplicative inverse (). Consequently, subtraction and division do not exist in Boolean algebra.
  • The Complement Operator: There is no equivalent to in real-number algebra.
  • Set Cardinality: Ordinary algebra deals with an infinite set of real numbers; two-valued Boolean algebra is strictly restricted to a set of two discrete values: .

3.1 Comparison: Boolean Algebra vs. Ordinary Algebra

FeatureBoolean AlgebraOrdinary Algebra
Set of ElementsStrictly two discrete elements: .Infinite set of real numbers ().
Arithmetic OperatorsLogical OR () and Logical AND ().Addition (), Subtraction (), Multiplication (), Division ().
Inverse OperatorsNone (no subtraction or division).Subtraction (additive inverse) and Division (multiplicative inverse).
Dual Distributive LawValid: .Invalid: (e.g. ).
Complement OperatorSingle unary complement () defined by .No complement operator.
Idempotent LawValid: .Invalid: .

4. The Consensus Theorem

Syllabus Context: High-Yield Exam Theorem

State and prove the Consensus Theorem is a common 6-mark theory question in Term Exams.

The Consensus Theorem is an algebraic simplification rule that eliminates redundant terms.

Theorem Statement:

And its dual form:

Step-by-Step Proofs:

A. Original Form ():

  1. Multiply the redundant term by :
  2. Distribute:
  3. Group terms and factor:
  4. Apply the Identity Law ():

B. Dual Form ():

  1. Add to the term :
  2. Expand the third term using the Distributive Law ():
  3. Rearrange terms:
  4. Simplify using the absorption law:

Rule of Thumb for Spotting Consensus in Algebraic Expressions

Look for three product terms where each of the three variables () appears exactly twice, with one of the variables complemented in one term and uncomplemented in another. The term without the complemented variable (the “consensus” of the other two, ) is completely redundant and can be deleted.


5. PYQ Master Proof: Duality & Deep Complementation

PYQ Master Proof (2018): Duality & Deep Complementation

Question: What is duality principle? Find the complement of the following Boolean function and reduce this complement function to a minimum number of literals:

Part A: The Duality Principle The Duality Principle states that every valid Boolean algebraic expression remains valid if we mathematically interchange all AND () operators with OR () operators, and simultaneously interchange all 0s with 1s, while keeping the variables themselves completely unchanged.

Part B: Simplification and Complementation Before applying De Morgan’s theorem to the whole expression, simplify the original function first:

Step 1: Apply De Morgan’s to the inner terms. Step 2: Apply the Distributive Law. Step 3: Apply the Null Law (). Step 4: Rearrange (Commutative Law).

The Final Complement: Since the original function perfectly reduces to absolute , its complement is simply: The minimum number of literals is zero (requires no variables, just a constant HIGH wire).


Past Year Questions (PYQs)

  • [PYQ 2015, 2016, 2018, 2019, 2022]: Define Duality principle and postulates of Boolean algebra.
  • [PYQ 2015, 2018]: Show that the Dual of exclusive-OR is equal to its complement.
  • [PYQ 2018]: Find the complement of and reduce to minimum number of literals. (08 Marks)
  • [PYQ 2016, 2023]: State and prove the Consensus Theorem. (06 Marks)

Related Concepts: 01 Boolean Algebra Foundations & Duality Principle | 03 SOP, POS, Canonical & Standard Forms | 05 Tabular Method (Quine-McCluskey) & Prime Implicants

3.02 Boolean Algebra Significance & Circuit Minimization

What is Boolean Algebra?

Boolean Algebra {Switching Algebra} is the mathematical system used to analyze, model, and simplify binary digital circuits. Variables are strictly restricted to two discrete binary states: 0 (LOW/OFF) and 1 (HIGH/ON).


1. Why Do We Simplify Boolean Expressions?

graph TD
    Min[Boolean Expression Minimization] --> C1[1. Reduces Hardware Cost]
    Min --> C2[2. Decreases Gate Fan-in]
    Min --> C3[3. Lowers Power Consumption]
    Min --> C4[4. Reduces Propagation Delay]
    Min --> C5[5. Saves Silicon / PCB Space]
    Min --> C6[6. Improves System Reliability]
    
    C1 --> G1[Fewer Logic Gates]
    C2 --> G2[Fewer Inputs per Gate]
    C3 --> G3[Less Current & Heat]
    C4 --> G4[Fewer Gate Levels = Faster]
    C5 --> G5[Smaller IC Package]
    C6 --> G6[Fewer Wiring Failure Points]

Six Key Engineering Reasons for Simplification:

  1. Reduces Hardware Cost: Direct reduction in total logic gate count on ICs.
  2. Decreases Gate Fan-in: Reduces input pin requirements per logic gate.
  3. Lowers Power Consumption: Reduces dynamic switching current and heat dissipation.
  4. Increases Speed (Reduces Propagation Delay): Decreases gate levels {cascading depth}, enabling higher clock frequencies.
  5. Saves Silicon Area: Reduces physical PCB footprint and silicon die size.
  6. Improves System Reliability: Fewer interconnects directly lower statistical failure rates.

2. Summary of Circuit Cost Metrics

Circuit Cost MetricDefinition & Engineering Impact
Gate CountTotal number of physical logic gates required.
Literal Count (Fan-in)Total number of variable appearances in the expression.
Number of Gate LevelsDepth of the longest path from input to output {propagation delay}.
Interconnection ComplexityTotal number of wiring connections between logic gates.

Past Year Questions (PYQs)

  • [PYQ 2020, 2024, 2025]: Significance of studying digital electronics and Boolean algebra.
  • [PYQ 2016, 2018, 2022, 2023]: Why do we simplify Boolean expressions? (06 to 10 Marks)

Related Concepts: 04 Mathematical Conversions & Expansion of SOP and POS | 01 Boolean Algebra Foundations & Duality Principle | 02 Boolean Algebra Significance & Circuit Minimization

3.03 SOP, POS, Canonical & Standard Forms

Introduction to Boolean Logic Forms

Any Boolean function can be expressed in two standard algebraic structures: Sum of Products (SOP) or Product of Sums (POS).

graph TD
    BF[Boolean Expressions] --> SOP[Sum of Products SOP]
    BF --> POS[Product of Sums POS]
    
    SOP -->|OR-ing AND terms| CSOP[Canonical SOP / Sum of Minterms Σm]
    SOP -->|Simplified| SSOP[Standard SOP e.g. AB + BC]
    
    POS -->|AND-ing OR terms| CPOS[Canonical POS / Product of Maxterms ΠM]
    POS -->|Simplified| SPOS[Standard POS e.g. A+B B+C]

1. Canonical Forms vs. Standard Forms

A. The Canonical Form (Strictly Unique)

Definition: Canonical Form

A Boolean expression is in Canonical Form if every term contains all domain variables of the function exactly once, in either complemented or uncomplemented form. Canonical forms are strictly unique.

  • Minterm (): An AND product term containing all domain variables. Evaluates to 1 for exactly one input state. Used in Canonical SOP ().
  • Maxterm (): An OR sum term containing all domain variables. Evaluates to 0 for exactly one input state. Used in Canonical POS ().

B. The Standard Form (Simplified / Non-Unique)

Definition: Standard Form

A Boolean expression is in Standard Form if it follows SOP or POS structure, but terms are simplified and do not need to contain all domain variables. Standard forms are non-unique.

C. Comparison: Canonical Forms vs. Standard Forms

ParameterCanonical FormStandard Form
Domain VariablesEvery term MUST contain all domain variables exactly once.Terms are simplified and do not need to contain all variables.
UniquenessUniquely represents a Boolean function. (Only one canonical form exists).Non-unique representation. (Multiple simplified standard forms exist).
Direct MappingDirectly maps to the truth table rows (minterms = 1, maxterms = 0).Does not map directly to rows without variable expansion.
Boolean TermsMinterms (for SOP) and Maxterms (for POS).Standard product terms and standard sum terms.
Algebraic LengthUsually long and redundant.Minimized and compact.
Gate EfficiencyHighly inefficient to implement directly.Optimal for hardware implementation (uses fewer gates).

2. Comparison Table: SOP vs. POS

ParameterSum of Products (SOP)Product of Sums (POS)
Basic StructureFormed by OR-ing multiple AND product terms.Formed by AND-ing multiple OR sum terms.
Truth Table SourceDerived from rows where output .Derived from rows where output .
Canonical ComponentSum of Minterms ().Product of Maxterms ().
Native Gate Realization2-level AND-OR or NAND-NAND logic.2-level OR-AND or NOR-NOR logic.

3. PYQ Master Problem: POS Canonical Extraction

PYQ Master Problem (2016): POS Canonical Extraction

Question: Given the function , construct the truth table and express the function in maxterm and minterm forms.

Step 1: Identify the Maxterms The function is given in canonical Product of Sums (POS) form. A maxterm evaluates to 0 when its uncomplemented variables are 0 and its complemented variables are 1:

Maxterm Form:

Step 2: Identify the Minterms Minterms are the remaining decimal states (0 through 7) not present in the maxterm list: Minterm Form:

Step 3: Construct the Truth Table

A B Cf(A,B,C)
0 0 01
0 0 10
0 1 01
0 1 10
1 0 01
1 0 10
1 1 01
1 1 10

(Notice simplifies to ).


Past Year Questions (PYQs)

  • [PYQ 2015, 2016, 2019, 2021, 2022, 2024]: Define Canonical form vs. Standard form.
  • [PYQ 2021, 2022]: Distinguish between canonical form and standard form of a Boolean function. (08 to 10 Marks)
  • [PYQ 2016]: POS Canonical Extraction, truth table construction, minterm/maxterm forms. (10 Marks)

Related Concepts: 03 SOP, POS, Canonical & Standard Forms | 01 Boolean Algebra Foundations & Duality Principle | 05 Tabular Method (Quine-McCluskey) & Prime Implicants

3.04 Mathematical Conversions & Expansion of SOP and POS

Concept Overview

Converting standard Boolean expressions into canonical Sum of Products (SOP) or Product of Sums (POS) form is accomplished algebraically via Missing-Variable Expansion.

graph TD
    Expression[Non-Canonical Expression] --> Type{Expansion Target}
    
    Type -->|Expand to SOP| SOPRule[Multiply term by x + x' = 1]
    SOPRule --> ExpandSOP[Apply Distributive Law: AB x+x' = ABx + ABx']
    ExpandSOP --> ListMinterms[List Sum of Minterms Σm]
    
    Type -->|Expand to POS| POSRule[Add xx' = 0 to sum term]
    POSRule --> ExpandPOS[Apply Distributive Law: X + YZ = X+Y X+Z]
    ExpandPOS --> ListMaxterms[List Product of Maxterms ΠM]

1. Algebraic Expansion Rules

  • SOP Expansion Rule: Multiply each non-canonical AND product term by for every missing variable .
  • POS Expansion Rule: Add to each non-canonical OR sum term for every missing variable , then expand via distribution: .

2. 4-Variable Canonical Expansion (Major PYQ)

Major PYQ Problem (2015, 2017, 2021 - 12 Marks)

Question: Express in Product of Maxterms () and Sum of Minterms () notation.

Solution:

Part 1: Product of Maxterms ()

  • Term 1 is missing :

  • Term 2 is missing and : Expanding via distribution yields 4 maxterms:

Part 2: Sum of Minterms ()

The minterm indices are the remaining numbers out of :


3. Class Test 01 Master Problem: SOP vs POS Gate Optimization

Class Test 01: SOP vs POS Gate Optimization

Question: Given : a) Convert into canonical SOP. b) Which implementation (SOP or POS) requires fewer logic gates?

Part A: Canonical SOP The minterm list is the exact inverse of the given maxterm list for a 4-variable system (0-15):

  • Minterms =
  • Canonical SOP:

Part B: Gate Optimization Justification To determine which implementation requires fewer gates, simplify both using K-maps:

  • SOP Simplification: Plotting 1s yields a quad and a quad .
  • POS Simplification: Plotting 0s yields . Complementing gives:
  • Conclusion: Both simplified expressions mathematically reduce to the exact same logic (an XOR gate, or 2 ANDs + 1 OR). Therefore, both SOP and POS require the exact same number of logic gates.

Past Year Questions (PYQs)

  • [PYQ 2015, 2017, 2021, 2024]: Express equations into full SOP (Sum of Minterms) and POS (Product of Maxterms) forms. (10 to 12 Marks)
  • [Class Test 01]: Canonical SOP conversion and SOP vs POS gate optimization analysis (). (10 Marks)

Related Concepts: 03 SOP, POS, Canonical & Standard Forms | 04 Mathematical Conversions & Expansion of SOP and POS | 06 Tabular Method (Quine-McCluskey) & Prime Implicants

3.05 Karnaugh Map (K-Map) Optimization & Don’t Care States

What is a Karnaugh Map?

A Karnaugh Map (K-map) is a graphical method used to simplify Boolean expressions without relying on algebraic manipulation. It organizes minterms or maxterms into a grid where adjacent cells differ by exactly one variable (satisfying the Gray Code adjacency property). This layout allows algebraic simplification () to be executed visually.


1. K-Map Grid Layouts (2, 3, and 4 Variables)

The rows and columns are indexed using Gray Code (00, 01, 11, 10 instead of binary 00, 01, 10, 11) to ensure adjacent cells differ by only one variable.

A. 3-Variable K-Map (8 Cells)

  • Map dimensions: .
  • Variables: (vertical), (horizontal).
      BC
  A  \ 00   01   11   10
    +----+----+----+----+
  0 | m0 | m1 | m3 | m2 |
    +----+----+----+----+
  1 | m4 | m5 | m7 | m6 |
    +----+----+----+----+

B. 4-Variable K-Map (16 Cells)

  • Map dimensions: .
  • Variables: (vertical), (horizontal).
       CD
  AB \ 00   01   11   10
    +----+----+----+----+
 00 | m0 | m1 | m3 | m2 |
    +----+----+----+----+
 01 | m4 | m5 | m7 | m6 |
    +----+----+----+----+
 11 | m12| m13| m15| m14|
    +----+----+----+----+
 10 | m8 | m9 | m11| m10|
    +----+----+----+----+

2. The Step-by-Step Grouping Rules

To simplify an SOP expression, place 1s in the cells corresponding to the minterms, and 0s for maxterms (for POS). Unused cells are filled with 0 (or 1).

The Adjacency Rules:

  1. Power of 2 Rule: Group sizes must be powers of 2 (i.e., loops of 1, 2, 4, 8, or 16 cells). No loops of 3, 5, or 6 cells are allowed.
  2. Standard Group Names:
    • Pair (2 cells): Eliminates 1 variable.
    • Quad (4 cells): Eliminates 2 variables.
    • Octet (8 cells): Eliminates 3 variables.
  3. Adjacency Wrapping: The edges of the map wrap around.
    • The left-most column is adjacent to the right-most column.
    • The top-most row is adjacent to the bottom-most row.
  4. Overlapping Groups: The same 1 can be used in multiple loops to make other loops as large as possible. Larger groups yield fewer literals!
  5. Redundant Groups: Avoid loops where all contained 1s are already covered by other essential loops.

The 4-Corner Trick

In a 4-variable K-map, the four corner cells () are physically adjacent to each other. They can be grouped together into a single Quad that simplifies directly to:


The Don’t Care () Rules:

In physical hardware (e.g., BCD decoders), some input combinations can never occur. These invalid states are called Don’t Cares and are marked as X in the grid.

  1. You may treat X as a 1 if it helps enlarge a group of 1s.
  2. You may treat X as a 0 (leave it uncovered) if it does not help enlarge a group.
  3. You never need to loop isolated X cells that do not cover any active 1s.

3. Prime Implicants (PI) vs. Essential Prime Implicants (EPI)

When grouping, you must distinguish between candidate loops and mandatory loops:

  • Prime Implicant (PI): A product term obtained by combining the maximum possible number of adjacent cells in the map. (It is a loop that cannot be doubled in size).
  • Essential Prime Implicant (EPI): A Prime Implicant that contains at least one 1 that is not covered by any other Prime Implicant.
  • Redundant Prime Implicant (RPI): A loop containing 1s that are completely covered by other select PIs.

Minimization Strategy

  1. Find all Prime Implicants on the map (loop all possible maximum groups).
  2. Identify Essential Prime Implicants (look for 1s that are only part of a single loop).
  3. Add all EPIs to the final Boolean expression.
  4. Cover any remaining uncovered 1s using the largest possible remaining PIs.

3.1 Differences: Prime Implicants (PI) vs. Essential Prime Implicants (EPI)

FeaturePrime Implicant (PI)Essential Prime Implicant (EPI)
DefinitionA maximal group of adjacent cells (cannot be combined into a larger group).A Prime Implicant that covers at least one 1 not covered by any other PI.
Inclusion in ExpressionMay or may not be included in the final minimized expression.MUST be included in the final minimized expression.
Uniqueness of CoverageAll of its 1s can potentially be shared with other groups.Contains at least one “unique 1” that is only coverable by this specific loop.
Identification MethodCircle the largest possible cell groups ().Look for circled 1s that are covered by only a single loop.
Role in Logic MinimizationForms the pool of candidate terms for logic minimization.Serves as the starting foundation terms for the final logic cover.

4. Worked Exam Examples

Example 1: 4-Variable SOP Minimization with Corners

Question: Simplify the Boolean function .

The K-Map Grid:

       CD
  AB \ 00   01   11   10
    +----+----+----+----+
 00 |  1 |  0 |  0 |  1 |  <- m0, m2 are 1s
    +----+----+----+----+
 01 |  0 |  1 |  1 |  0 |  <- m5, m7 are 1s
    +----+----+----+----+
 11 |  0 |  1 |  1 |  0 |  <- m13, m15 are 1s
    +----+----+----+----+
 10 |  1 |  0 |  0 |  1 |  <- m8, m10 are 1s
    +----+----+----+----+

Grouping Analysis:

  1. The Corner Quad: Minterms form a 4-corner group.
    • Vertical transition (): and remains constant.
    • Horizontal transition (): and remains constant.
    • Term 1:
  2. The Center Quad: Minterms form a center group.
    • Vertical transition (): and remains constant.
    • Horizontal transition (): and remains constant.
    • Term 2:


Example 2: 4-Variable SOP with Don’t Cares

Question: Simplify the Boolean function .

The K-Map Grid:

       CD
  AB \ 00   01   11   10
    +----+----+----+----+
 00 |  X |  1 |  1 |  X |  <- m0, m2 are Xs; m1, m3 are 1s
    +----+----+----+----+
 01 |  0 |  X |  1 |  0 |  <- m5 is X; m7 is 1
    +----+----+----+----+
 11 |  0 |  0 |  1 |  0 |  <- m15 is 1
    +----+----+----+----+
 10 |  0 |  0 |  1 |  0 |  <- m11 is 1
    +----+----+----+----+

Grouping Analysis:

  1. Column Quad: The entire right-middle column contains all 1s.
    • Horizontal position is remains constant.
    • Term 1:
  2. Top-Left Quad (using at 5): The cells form a quad. Cell is a Don’t Care (), which we treat as a 1 to enlarge the group.
    • Vertical transition (): and remains constant.
    • Horizontal transition (): and remains constant.
    • Term 2:
  3. The Unused Don’t Cares: Cells and are left uncovered since all 1s are already covered. Treating them as 1s would only create a redundant term ().


Example 3: POS Minimization (Grouping 0s)

Question: Simplify into Product-of-Sums (POS) form.

To find the minimized POS expression, we map the 0s of on the K-map, simplify for , and then apply De Morgan’s Law.

The K-Map Grid (showing 0s):

       CD
  AB \ 00   01   11   10
    +----+----+----+----+
 00 |  0 |  1 |  1 |  0 |  <- m0, m2 are 0s
    +----+----+----+----+
 01 |  0 |  1 |  1 |  0 |  <- m4, m6 are 0s
    +----+----+----+----+
 11 |  1 |  1 |  1 |  1 |  <- No 0s in this row
    +----+----+----+----+
 10 |  1 |  1 |  0 |  0 |  <- m10, m11 are 0s
    +----+----+----+----+

Grouping 0s for :

  1. Vertical Quad of 0s: Cells form a vertical quad on the outer columns.
    • Vertical transition (): and remains constant.
    • Horizontal transition (): and remains constant.
    • Term 1 ():
  2. Horizontal Pair of 0s: Cells form a horizontal pair.
    • Vertical position is remains constant.
    • Horizontal transition (): and remains constant.
    • Term 2 ():
  3. Vertical Pair of 0s (Wrapping): Cells wrap from top to bottom.
    • Vertical transition (): and remains constant.
    • Horizontal position is remains constant.
    • Term 3 ():

Combining for :

Applying De Morgan’s Law ():


5. 5-Variable K-Map Minimization (Three-Dimensional Adjacency) [Syllabus Week 5]

Foundational Concept (Outside Direct PYQ Scope)

5-variable K-maps represent a foundational concept in multi-variable logic minimization, but they have never appeared in ECE 2103 past year papers (which strictly test up to 4-variable K-maps). It is included here to provide complete theoretical foundation.

A 5-variable function requires minterms. Grouping variables across 32 cells requires a three-dimensional mapping strategy.

5.1 Plane Overlay Concept

Instead of a single 32-cell grid, we construct two standard 4-variable () K-maps side-by-side:

  • Plane A = 0 (Left Grid): Contains minterms ( horizontal, vertical).
  • Plane A = 1 (Right Grid): Contains minterms ( horizontal, vertical).
       A = 0 (m0 - m15)                      A = 1 (m16 - m31)
            BC                                    BC
        00  01  11  10                        00  01  11  10
      +---+---+---+---+                     +---+---+---+---+
   00 | m0| m1| m3| m2|                  00 |m16|m17|m19|m18|
      +---+---+---+---+                     +---+---+---+---+
   01 | m4| m5| m7| m6|                  01 |m20|m21|m23|m22|
DE    +---+---+---+---+                  DE +---+---+---+---+
   11 |m12|m13|m15|m14|                  11 |m28|m29|m31|m30|
      +---+---+---+---+                     +---+---+---+---+
   10 | m8| m9|m11|m10|                  10 |m24|m25|m27|m26|
      +---+---+---+---+                     +---+---+---+---+

5.2 Adjacency & Grouping Rules

  1. Grid Adjacency: Standard grouping rules (pairs, quads, octets, wrapping) apply individually to both the plane and the plane.
  2. Plane-Overlay Adjacency: Imagine the plane is stacked directly on top of the plane. Cells in the same row/column coordinates on both maps are adjacent.
    • If a group of cells exists in the exact same position on both the and planes, they can be merged into a single group. The variable changes state () and is eliminated from the term.
    • If a group exists only on the plane, the term must contain .
    • If a group exists only on the plane, the term must contain .

Worked Example: 5-Variable Minimization

Question: Simplify the function .

Step 1: Plot the Planes

  • On plane, plot 1s at: .
  • On plane, plot 1s at: .

Step 2: Grouping Analysis

  1. Outer Row Quads (Plane Overlay):
    • On plane, cells form a vertical-wrap quad on columns and rows . This quad simplifies to .
    • On plane, the same positions are also filled with 1s, forming the identical quad .
    • Overlay Merge: Merge these two quads. is eliminated Term 1: .
  2. Right-Side Quads (Plane Overlay):
    • On plane, cells form a quad in columns and rows . This quad simplifies to .
    • On plane, the same positions are also filled with 1s, forming the identical quad .
    • Overlay Merge: Merge these two quads. is eliminated Term 2: .


6. Past Year Questions (PYQs) [PYQ 2016, 2018, 2022, 2023]

  • [PYQ 2022, 2023]: Simplify Boolean function using K-map. (10 Marks)
  • [PYQ 2016, 2018]: Simplify functions combining both SOP & POS using K-maps, including “Don’t Care” conditions. (12 Marks)

Related Concepts: 3.02 Boolean Algebra Significance & Circuit Minimization | 3.04 Mathematical Conversions & Expansion of SOP and POS | 3.05 Karnaugh Map (K-Map) Optimization & Don’t Care States | 3.07 Boolean Algebra Puzzles & Exam Proofs

3.06 Tabular Method (Quine-McCluskey) & Prime Implicants

Concept Overview: Tabular Method

While Karnaugh maps are ideal for up to 4 variables, they become visually impractical for 6 or more variables. The Tabular Method (Quine-McCluskey) is an algorithmic, tabular minimization method that guarantees the exact minimal standard-form expression for any number of variables.

graph TD
    Minterms[Input Minterms Σm] --> Phase1[Phase 1: Determine Prime Implicants]
    Phase1 --> Group1s[Group Minterms by Count of 1s]
    Group1s --> MatchPairs[Match Adjacent Groups Differing by Power of 2]
    MatchPairs --> MarkUnticked[Unticked Terms = Prime Implicants]
    
    MarkUnticked --> Phase2[Phase 2: Selection Table]
    Phase2 --> FindSingleX[Identify Columns with Single X]
    FindSingleX --> SelectEPI[Select Essential Prime Implicants]
    SelectEPI --> CoverRest[Select Minimum Remaining PIs to Cover All Minterms]
    CoverRest --> MinExpr[Minimal Boolean Function]

1. Core Definitions

  • Prime Implicant (PI): A product term obtained by combining the maximum possible number of adjacent minterm squares. If a product term cannot be combined with any other term to eliminate a variable, it is a Prime Implicant.
  • Essential Prime Implicant (EPI): A prime implicant that covers at least one minterm that is not covered by any other prime implicant. All EPIs must be included in the final minimal expression.

2. Step-by-Step Methodology

Phase 1: Determination of Prime Implicants

  1. Group Minterms (and Don’t Cares): Convert all decimal minterms and don’t-care conditions to binary. Group them together based on the number of 1s in their binary representation.
  2. Compare Adjacent Groups: Compare every term in Group with every term in Group .
  3. Power of 2 Rule: Two terms combine if they differ in exactly one bit position (which is a power of 2: ).
  4. Record & Check: Write the combined pair in the next column, replacing the differing bit with a dash (-) (e.g., 0,8 (8) or 0,8 (-000)). Place a check () next to both combined terms.
  5. Iterate: Repeat this matching process for Column 2 to create Column 3, Column 3 to create Column 4, etc. You can only combine terms that have the dash (-) in the exact same position.
  6. Identify PIs: Any term that remains unchecked () at the end of the entire process is a Prime Implicant (PI).

Phase 2: Selection Table (Find Minimal Cover)

  1. Selection Table Grid: Construct a grid where:
    • Rows: The list of all identified Prime Implicants.
    • Columns: The original minterms ONLY.

    Don't-Care Column Rule Never include don't-care conditions as columns in the selection table! Don't-cares are only used in Phase 1 to help expand the loops (prime implicants) as much as possible, but we are under no obligation to cover them in the final minimized expression.

  2. Mark Intersections: Place an X at the intersection of a PI row and a minterm column if that PI covers that minterm.
  3. Identify Essential Prime Implicants (EPIs):
    • Scan each column from left to right.
    • Look for columns containing exactly one X.
    • The PI row associated with that single X is an Essential Prime Implicant. Star () or circle this row; it must be included in the final function.
    • Cross out the selected EPI row and all columns covered by this EPI.
  4. Select Remaining PIs: For any remaining uncovered minterm columns, choose the minimum number of remaining PIs to complete the coverage.

3. PYQ Solution: 4-Variable Tabular Minimization

Major PYQ Problem (2023, 2025 - 10 Marks)

Question: Simplify using the Tabular Method.

Solution:

Phase 1: Prime Implicant Determination Table

GroupColumn 1 (Minterms)Column 2 (Pairs)Column 3 (Quads)
G0
G1
G2
G3
G4
  • Un-ticked Prime Implicants:
    1. 0,1 (1)
    2. 0,2,8,10 (2,8)
    3. 10,11,14,15 (1,4)

Phase 2: Selection Table

Prime Implicant012810111415Status
X(X)EPI (Covers 1)
X(X)(X)XEPI (Covers 2, 8)
X(X)(X)(X)EPI (Covers 11, 14, 15)


4. 6-Variable Tabular Setup (Exam Monster)

Major PYQ Monster Problem (2024 - 14 Marks)

Question: Determine prime implicants using Tabular Method for .

Setup Analysis:

  • Variables: Possible pair differences are powers of 2: .
  • Group 2 (Two 1s):
  • Group 3 (Three 1s):
  • Group 4 (Four 1s):
  • Group 5 (Five 1s):

(Note: Minterm 6 cannot combine with any Group 3 term is an immediate Prime Implicant!)


Past Year Questions (PYQs)

  • [PYQ 2018]: Define Prime Implicants with example. (03 Marks)
  • [PYQ 2023, 2025]: 4-variable Tabular simplification. (10 Marks)
  • [PYQ 2024]: 6-variable 14M Tabular prime implicant determination. (14 Marks)

Related Concepts: 3.01 Boolean Algebra Foundations & Duality Principle | 3.04 Mathematical Conversions & Expansion of SOP and POS | 3.05 Karnaugh Map (K-Map) Optimization & Don’t Care States | 3.06 Tabular Method (Quine-McCluskey) & Prime Implicants

3.07 Boolean Algebra Puzzles & Exam Proofs

Exam Edge Cases & Mathematical Puzzles

High-yield exam questions often include 9 to 11-mark mathematical “puzzles” testing reverse-engineering, factoring constraints, and multi-variable gate expansions.


1. The 5-Variable “Reverse Don’t Care” Puzzle

Major PYQ Problem (2017, 2020 - 11 Marks)

Question: The expression is a simplified version of . Are there any don’t care conditions? If so, what are they?

Solution:

Step 1: Minterms of Unsimplified Expression ()

Expand each 5-variable term ():

Step 2: Minterms of Simplified Expression ()

Step 3: Isolate Don’t Care Minterms


2. The 8-Literal Limit Factoring Puzzle

Major PYQ Problem (2022 - 9 Marks)

Question: Express in three different ways using 8 or fewer literals.

Solution:

Way 1: Group by and

Using absorption identity :

Way 2: Group by and

Expand Way 1:

Way 3: Group by and


3. 4-Variable XNOR Expansion Proof

OCR Exam Scanner Typo Correction

PYQ 2017 text writes . This is an OCR typo. Minterm 0 () evaluates to 0 in XOR. The true textbook question (Morris Mano 4-23) uses XNOR ().

Major PYQ Proof (2017 - 10 Marks)

Question: Show that .

Proof Solution:

Let and .

Substitute into : Evaluating these 8 product terms:


Past Year Questions (PYQs)

  • [PYQ 2017, 2020]: 5-variable Reverse Don’t Care condition puzzle. (11 Marks)
  • [PYQ 2022]: Express Boolean function with 8 or fewer literals. (09 Marks)
  • [PYQ 2017]: Show that . (10 Marks)