4.6 Minterms: Numbering the Rows Where a Function Is True

Define a minterm as a product term true for exactly one input combination, correctly compute a minterm's decimal index from a variable assignment, and read/write Σm(...) notation.

A minterm is a special kind of product (AND) term, built from every one of a function's variables (each appearing either true or complemented, never omitted), that evaluates to 1 for exactly one specific combination of input values and to 0 for every other combination. Minterms matter because they give every single row of a truth table its own unique, individually addressable Boolean expression, which is exactly what makes it possible to describe an entire function compactly as 'the OR of the minterms for every row where the function is 1' — the Σm(...) notation this topic introduces — rather than having to write out a full truth table or a hand-derived SOP expression every time.

Core Concept: One Term, One Row

For a function of n variables, there are exactly 2ⁿ possible input combinations, and correspondingly exactly 2ⁿ distinct minterms — one per row of the truth table. Each minterm is formed by ANDing together every one of the n variables, choosing the true (uncomplemented) form of a variable if that row has it equal to 1, and the complemented form if that row has it equal to 0. This construction guarantees the minterm evaluates to 1 on exactly that one row: every variable in the term matches its row's value exactly, so the AND of all of them is 1, while on any other row at least one variable will mismatch (a 1 where the term expects 0, or vice versa), zeroing the whole product.

Minterms are conventionally numbered using the decimal value of the binary pattern their row represents, read with the first-listed variable as the most significant bit. The spec's tricky point makes this numbering convention explicit and warns that it is not automatic: minterm numbering depends on the variable order, and for the ordering ABC, the binary pattern 101 corresponds to decimal 5 — meaning A=1, B=0, C=1 is minterm number 5, specifically because reading '101' as a binary number (with A as the most significant bit) equals 5 in decimal.

• A minterm includes every variable of the function, each in true or complemented form — never omitted. • Each minterm is 1 for exactly one input row, and 0 for every other row. • Minterm index = the decimal value of the row's binary pattern, with the first-listed variable as the most significant bit. • The spec's tricky point: for ordering ABC, binary 101 (A=1,B=0,C=1) is minterm 5 — numbering depends entirely on variable order.

Step-by-Step: From a Truth Table Row to a Minterm's Index and Expression

To find a specific row's minterm expression, write down every variable in order, choosing the uncomplemented form where that row has a 1 and the complemented form where it has a 0 — for the row A=1,B=0,C=1, this produces the term A·B'·C (A is 1 so uncomplemented, B is 0 so complemented, C is 1 so uncomplemented). To find that same minterm's decimal index, treat the row's bit pattern (101, in variable order ABC) as a plain binary number and convert it to decimal: 101₂ = 1·4 + 0·2 + 1·1 = 5 — matching the spec's example exactly.

The reverse direction — given a minterm index, recover the row it represents — runs the same conversion backward: convert the index to binary using enough bits for the number of variables (3 bits for 3 variables), and read each bit position against the established variable order to get that variable's value for this minterm. This bidirectional fluency (row → index, and index → row) is essential, because Σm(...) notation (introduced next) only lists indices, and working with it requires being able to reconstruct the underlying rows from those indices at will.

• Step 1 (row → term): write every variable, uncomplemented if that row's value is 1, complemented if 0. • Step 2 (row → index): read the row's bit pattern as binary (first variable = most significant bit) and convert to decimal. • Step 3 (index → row): convert the index back to an n-bit binary pattern and map each bit back to its variable in order. • Spec confirms: ABC ordering, pattern 101, → decimal index 5.

Practical and Real-World Application: Σm(...) Notation and Synthesis Tools

The spec introduces the compact notation Σm(...) — read 'sum of minterms' — directly, with the worked example F(A,B,C) = Σm(1,3,5,7), meaning F is the OR (sum) of minterm 1, minterm 3, minterm 5, and minterm 7, and 0 on every other row not listed. This notation is exactly how truth-table-derived functions are compactly recorded in textbooks, datasheets, and digital design tools, avoiding the need to draw out a full truth table or write a lengthy SOP expression every time a function needs to be referenced.

This minterm-index representation is also precisely the internal format many logic-synthesis and K-map-based minimization tools use to accept a function's specification: rather than requiring a hand-derived Boolean expression as input, a tool can simply be told 'this function is 1 for these minterm indices', and it derives the minimized circuit from there — which is exactly the workflow Module 5's Karnaugh maps formalize by hand.

Common Mistake and the Tricky Concept

The spec's tricky point deserves to be treated as an absolute rule, not a minor detail: minterm numbering depends on the variable order. Two people working with the exact same underlying truth table but listing their variables in a different order (say, CBA instead of ABC) will assign different minterm indices to the exact same input row — the row A=1,B=0,C=1 is minterm 5 under ABC ordering but would be a different index under a different variable order, because the bit pattern read as binary changes when the digit order changes. Always state (or confirm) the variable order before interpreting or comparing Σm(...) notation between two sources.

A second, related trap is miscounting bit positions when converting between a row and its index — particularly forgetting which variable is the most significant bit. The spec's convention (and the standard convention throughout this course) is that the first-listed variable in the function's argument list, such as the A in F(A,B,C), is the most significant bit of the index; reversing this assumption silently produces a wrong index for every row except the symmetric ones (all-0s and all-1s).

Minterm Notation

Σ is the summation/OR symbol here — 'sum of minterms' means OR-ing the listed minterms together. Minterm index numbering always depends on the stated variable order (e.g. ABC vs. CBA).

Notation:
  Σm(...)      "sum of minterms"

Example:
  F(A,B,C) = Σm(1,3,5,7)

Meaning: F = 1 for the rows whose ABC binary pattern equals
1, 3, 5, or 7 in decimal; F = 0 for every other row.

Code Examples

This directly reconstructs the spec's own stated fact. Writing A uncomplemented (since A=1), B complemented (since B=0), and C uncomplemented (since C=1) gives the minterm's Boolean expression, A·B'·C, and reading the same row's bit pattern as a binary number under ABC ordering converts to decimal 5 — the two representations (Boolean term and decimal index) describe the exact same single truth-table row. Expected result: Minterm index 5

Row A=1,B=0,C=1 = minterm 5 = term A·B'·C (under ABC ordering)

This is the spec's own example function, expanded from its Σm(...) shorthand into the full canonical SOP expression: each listed index is converted back to its 3-bit binary row pattern, and each row is written out as its corresponding minterm term, with all four terms OR'd together. Notice that every listed index (1,3,5,7) has C=1 in its binary pattern (the odd numbers) — this function is actually always true whenever C=1, regardless of A or B, meaning it could be simplified all the way down to F=C, a preview of the Boolean simplification covered in Module 4.9.

Σm(1,3,5,7) = A'B'C + A'BC + AB'C + ABC

Ordering: A, B, C
Row: A=1, B=0, C=1

Minterm expression: A · B' · C
Binary pattern (A=MSB): 1 0 1
Decimal index: 1·4 + 0·2 + 1·1 = 5

Confirms the spec's tricky problem: pattern 101 (ABC order) = minterm 5.

m1 = 001 = A'B'C
m3 = 011 = A'BC
m5 = 101 = AB'C
m7 = 111 = ABC

F = A'B'C + A'BC + AB'C + ABC

Minterm Index Table for 3 Variables (Order: A, B, C)

Index = binary row pattern read in decimal, with A as the most significant bit.

Index | A B C | Minterm term
------+-------+---------------
  0   | 0 0 0 | A'B'C'
  1   | 0 0 1 | A'B'C
  2   | 0 1 0 | A'BC'
  3   | 0 1 1 | A'BC
  4   | 1 0 0 | AB'C'
  5   | 1 0 1 | AB'C
  6   | 1 1 0 | ABC'
  7   | 1 1 1 | ABC

Important Rules

A minterm includes every variable of the function, in true or complemented form, never omitted.

A minterm is 1 for exactly one input row and 0 for every other row.

Minterm index = decimal value of the row's bit pattern, with the first-listed variable as most significant bit.

Minterm numbering depends entirely on the stated variable order — always confirm the order before comparing Σm(...) notation across sources.

Compact Function Specification for Synthesis Tools

Σm(...) notation is the standard compact way truth-table-derived functions are recorded in textbooks, datasheets, and digital-logic synthesis and K-map tools — rather than drawing a full truth table, a designer or a tool simply lists the minterm indices where the function is 1, which is both faster to write and directly usable as input to automated minimization software.

Assuming a minterm index like '5' means the same input row regardless of which variable order (ABC, BCA, CAB, ...) is being used.

Always fix and state the variable order first; the same decimal index maps to a different underlying row under a different variable ordering, because the binary-to-decimal conversion depends on bit position, which depends on order.

The spec's tricky problem states this directly: 'Minterm numbering depends on the variable order. For ABC, the binary pattern 101 corresponds to decimal 5.' Changing the order changes which row each index refers to.

[tricky-problem] Under the variable ordering A, B, C, which decimal index corresponds to the binary pattern 101 (A=1, B=0, C=1)? A. 3 B. 5 C. 6 D. It cannot be determined without more information

B. 5 — The spec states this exact fact directly: 'For ABC, the binary pattern 101 corresponds to decimal 5.' Reading 101 as a binary number with A as the most significant bit gives 1·4 + 0·2 + 1·1 = 5.

[interview] Why does the spec emphasize that minterm numbering 'depends on the variable order'? A. Because minterm numbers are arbitrary and carry no real meaning. B. Because the same decimal index refers to a different underlying input row if the stated order of the variables changes, since the index is derived from reading the row's bits as binary in that specific order. C. Because minterms only exist for functions with exactly three variables. D. Because minterm indices must always be listed in ascending order.

B. Because the same decimal index refers to a different underlying input row if the stated order of the variables changes, since the index is derived from reading the row's bits as binary in that specific order. — A minterm's decimal index comes directly from treating its row's bit pattern as a binary number, with the first-listed variable as the most significant bit. Changing which variable is listed first (and thus which bit is most significant) changes the resulting decimal value for the exact same underlying row, so the variable order must always be fixed and known before Σm(...) notation can be correctly interpreted.

For a function G(A,B,C,D) using the ordering A,B,C,D, write the minterm expression and compute the decimal index for the row A=1, B=1, C=0, D=1.

Minterm expression: A·B·C'·D. Bit pattern: 1101. Decimal index: 1·8 + 1·4 + 0·2 + 1·1 = 13. This row is minterm 13 under ABCD ordering.

Write each variable true/complemented per its row value, then read the 4-bit pattern as binary with A as the most significant bit.