4.7 Maxterms: Numbering the Rows Where a Function Is False

Define a maxterm as a sum term false for exactly one input combination, relate maxterms to minterms as their structural and numeric complements, and read/write ΠM(...) notation.

A maxterm is the structural mirror image of a minterm: instead of a product (AND) term that is 1 for exactly one row, a maxterm is a sum (OR) term, built from every one of a function's variables, that is 0 for exactly one specific row and 1 for every other row. Maxterms matter for exactly the reason minterms do, but from the opposite direction — they give every row of a truth table its own individually addressable OR-based expression, which is what makes it possible to describe a function compactly as 'the AND of the maxterms for every row where the function is 0', using the ΠM(...) notation this topic introduces, and to build a function's canonical POS form directly and mechanically.

Core Concept: One Factor, One Excluded Row

For a function of n variables, there are exactly 2ⁿ possible input combinations and correspondingly exactly 2ⁿ distinct maxterms — one per row, exactly mirroring minterms. Each maxterm is formed by ORing together every one of the n variables, but with the opposite complementation rule from minterms: choose the complemented form of a variable if that row has it equal to 1, and the uncomplemented form if that row has it equal to 0. This inverted rule guarantees the maxterm evaluates to 0 on exactly that one row (every OR'd term mismatches its row's actual value, so each individual disjunct is 0, and OR of all 0s is 0) and 1 on every other row (at least one term will match, producing a 1 that dominates the OR).

Maxterm indexing follows the identical binary-to-decimal convention used for minterms — the maxterm's index is the decimal value of the row's binary pattern, read with the first-listed variable as the most significant bit. The critical relationship to hold onto is that maxterm M_i is the exact logical complement of minterm m_i, for the same index i and the same row: M_i = (m_i)'. This means every fact learned about minterm numbering (Module 4.6), including the spec's warning that numbering depends on variable order, applies identically and without modification to maxterms.

• A maxterm includes every variable of the function, each in true or complemented form (opposite complementation rule from minterms). • Each maxterm is 0 for exactly one input row, and 1 for every other row — the structural mirror of a minterm. • Maxterm index uses the identical row-to-decimal convention as minterm index (first-listed variable = most significant bit). • M_i = (m_i)' — the maxterm at index i is always the exact complement of the minterm at that same index i.

Step-by-Step: From a Truth Table Row to a Maxterm's Expression

To find a specific row's maxterm expression, write down every variable in order, choosing the complemented form where that row has a 1 and the uncomplemented form where it has a 0 — note this is exactly backwards from the minterm rule. For the row A=0, B=0, C=0 (index 0 under ABC ordering), every variable is 0, so every variable appears uncomplemented, giving the sum term (A+B+C) — and checking this against the row confirms it: with A=B=C=0, (A+B+C) evaluates to 0+0+0=0, correctly matching maxterm 0's defining property of being 0 at exactly its own row.

The relationship M_i = (m_i)' offers a fast shortcut once you're already comfortable with minterms: rather than re-deriving a maxterm's OR-based expression from scratch by the complement-and-OR rule above, you can instead find the corresponding minterm's AND-based expression (Module 4.6's method) and simply apply De Morgan's law (Module 4.3) to it — complementing an AND-of-variables term via De Morgan's rule automatically produces an OR-of-complemented-variables term, which is exactly a maxterm. Both methods always agree, since they describe the same underlying identity.

• Step 1 (row → term): write every variable, complemented if that row's value is 1, uncomplemented if 0 (opposite of minterms). • Step 2 (row → index): identical to minterms — read the row's bit pattern as binary and convert to decimal. • Shortcut: find the minterm for the same row, then apply De Morgan's law to get the maxterm directly: M_i = (m_i)'. • Spec example: F(A,B,C) = ΠM(0,2,4,6) — the AND of maxterms 0, 2, 4, and 6.

Practical and Real-World Application: ΠM(...) Notation and Canonical POS

The spec introduces Π M(...) — read 'product of maxterms' — directly, with the worked example F(A,B,C) = ΠM(0,2,4,6), meaning F is the AND (product) of maxterm 0, maxterm 2, maxterm 4, and maxterm 6, and 1 on every other row not listed (since a function is only forced to 0 by a maxterm at that maxterm's own specific row). This is the exact numeric-index counterpart to Σm(...) notation, but built around a function's 0-rows instead of its 1-rows, and it is precisely how a function's canonical POS expression (Module 4.8) is mechanically constructed: AND together the maxterm expression for every listed index.

Choosing between Σm(...) and ΠM(...) notation for a given function in practice is a matter of which representation is more compact: a function with very few 0-rows (many 1-rows) is naturally described more concisely by ΠM(...), listing only its handful of 0-indices, while a function with very few 1-rows is more concisely described by Σm(...) — the same sparse-representation logic that motivates choosing POS over SOP (or vice versa) discussed in Module 4.5.

Common Mistake and the Tricky Concept

The most common mistake is applying the minterm complementation rule when building a maxterm, or vice versa — for instance, writing maxterm 0 (row A=B=C=0) using complemented variables (A'+B'+C') by force of habit from the minterm construction, instead of the correct uncomplemented form (A+B+C). Always double-check which rule you're applying: minterms use 'true value → uncomplemented variable', while maxterms use the opposite, 'true value → complemented variable'.

A second subtlety is forgetting that ΠM(...) lists the rows where the function is 0, not where it is 1 — this is the reverse of Σm(...), which lists 1-rows. Misreading ΠM(0,2,4,6) as 'the function is 1 at rows 0,2,4,6' (applying Σm(...)'s convention by mistake) produces the exact logical complement of the intended function, a serious and easy-to-make error when switching between the two notations.

Maxterm Notation

Π is the product/AND symbol here — 'product of maxterms' means AND-ing the listed maxterms together. ΠM(...) lists 0-rows; Σm(...) lists 1-rows — the two notations are complementary, not interchangeable.

Notation:
  ΠM(...)      "product of maxterms"

Example:
  F(A,B,C) = ΠM(0,2,4,6)

Meaning: F = 0 for the rows whose ABC binary pattern equals
0, 2, 4, or 6 in decimal; F = 1 for every other row.

Key relationship:
  M_i = (m_i)'   (maxterm i is the exact complement of minterm i)

Code Examples

Maxterm 0 uses the opposite complementation rule from minterm 0: because every variable is 0 at this row, each appears uncomplemented in the sum. Evaluating the resulting OR term at its own defining row confirms it correctly evaluates to 0, and evaluating it at any other row confirms it correctly evaluates to 1 — exactly the defining property of a maxterm.

Maxterm 0 = (A+B+C), which is 0 only at A=B=C=0 This is the spec's own example function, expanded from its ΠM(...) shorthand into the full canonical POS expression: each listed index is converted back to its 3-bit binary row, and each row's maxterm term is written using the complemented-if-1 rule, with all four factors ANDed together. Notice every listed index (0,2,4,6) has C=0 in its binary pattern (the even numbers) — meaning this function is forced to 0 only when C=0, and reads 1 whenever C=1, so it could simplify all the way to F=C, the exact same underlying function used as the minterm example in Module 4.6 (Σm(1,3,5,7) also reduced to F=C) — a clean illustration that a single function can have both a minterm-based and a maxterm-based description.

ΠM(0,2,4,6) = (A+B+C)(A+B'+C)(A'+B+C)(A'+B'+C)

Ordering: A, B, C
Row: A=0, B=0, C=0  (index 0)

Maxterm expression: (A + B + C)     [uncomplemented, since each variable's value is 0]
Check: (0 + 0 + 0) = 0              — correctly 0 at its own row
Check at a different row, A=1,B=0,C=0: (1+0+0) = 1  — correctly 1 elsewhere

M0 = 000 → (A+B+C)
M2 = 010 → (A+B'+C)
M4 = 100 → (A'+B+C)
M6 = 110 → (A'+B'+C)

F = (A+B+C)(A+B'+C)(A'+B+C)(A'+B'+C)

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

Same index numbering as minterms, but the complementation rule is reversed.

Index | A B C | Maxterm term
------+-------+------------------
  0   | 0 0 0 | (A + B + C)
  1   | 0 0 1 | (A + B + C')
  2   | 0 1 0 | (A + B' + C)
  3   | 0 1 1 | (A + B' + C')
  4   | 1 0 0 | (A' + B + C)
  5   | 1 0 1 | (A' + B + C')
  6   | 1 1 0 | (A' + B' + C)
  7   | 1 1 1 | (A' + B' + C')

Important Rules

A maxterm includes every variable of the function, in true or complemented form (opposite rule from minterms), never omitted.

A maxterm is 0 for exactly one input row and 1 for every other row — the structural mirror of a minterm.

Maxterm index numbering follows the identical convention as minterm indexing, and equally depends on variable order.

M_i = (m_i)' for every index i — maxterms and minterms at the same index are always exact complements of each other.

Canonical POS Construction and Sparse-Zero Functions

ΠM(...) notation is the mechanical basis for building a function's canonical POS expression (Module 4.8): AND together the maxterm expression for every listed index. It is the natural, most compact choice for functions with very few 0-outputs, the mirror-image scenario to when Σm(...)/SOP is preferred for functions with very few 1-outputs.

Building a maxterm using the minterm complementation rule (uncomplemented when the row value is 1) instead of the maxterm's own rule (complemented when the row value is 1).

Apply the maxterm-specific rule: complement a variable when its row value is 1, leave it uncomplemented when its row value is 0 — the exact opposite of the minterm rule.

Confusing the two rules produces the minterm's own expression relabeled as a maxterm, which is 1 at exactly the wrong single row (1 where the maxterm should be 0, and vice versa) — since M_i must equal (m_i)', building it with the minterm's rule instead of complementing correctly breaks that relationship.

What is the exact relationship between the maxterm and minterm at the same index i? A. They are always identical expressions. B. M_i = (m_i)' — the maxterm at index i is the exact logical complement of the minterm at that same index. C. Maxterms and minterms use entirely unrelated indexing systems. D. M_i is always twice the value of m_i.

B. M_i = (m_i)' — the maxterm at index i is the exact logical complement of the minterm at that same index. — A minterm is 1 only at its own row and 0 elsewhere; a maxterm is 0 only at its own row and 1 elsewhere. Complementing a minterm therefore flips it to be 0 only at that same row and 1 elsewhere — exactly the definition of the maxterm at that same index, giving M_i = (m_i)'.

[interview] If ΠM(0,2,4,6) describes a function, at which rows is the function equal to 1? A. Only at rows 0, 2, 4, and 6 B. At every row except 0, 2, 4, and 6 C. At every row, with no exceptions D. The function is undefined outside the listed indices

B. At every row except 0, 2, 4, and 6 — ΠM(...) notation lists the rows where the function equals 0 (each listed maxterm forces the AND to 0 at its own row). The function equals 1 everywhere else — i.e., at every row not in the list. Confusing this with Σm(...)'s convention (which lists 1-rows) produces the function's exact complement, a common and serious error.

For the ordering A, B, C, write the maxterm expression for the row A=1, B=0, C=1 (index 5), and verify it evaluates to 0 only at that row (check one other row too).

Maxterm 5 = (A'+B+C'), since A=1→A', B=0→B (uncomplemented), C=1→C'. Check at its own row (1,0,1): (0+0+0)=0 — correct. Check at row (0,0,0): (1+0+1)=1 — correctly nonzero elsewhere.

Apply the maxterm rule: complement a variable exactly where its row value is 1.